The Smart Beaver from ABBYY got hooked on square matrices. Now he is busy studying an n × n size matrix, where n is odd. The Smart Beaver considers the following matrix elements good:    Elements of the main diagonal.   Elements of the secondary diagonal.   Elements of the "middle" row — the row which has exactly  rows above it and the same number of rows below it.   Elements of the "middle" column — the column that has exactly  columns to the left of it and the same number of columns to the right of it.    The figure shows a 5 × 5 matrix.   The good elements are marked with green.  Help the Smart Beaver count the sum of good elements of the given matrix.

The first line of input data contains a single odd integer n. Each of the next n lines contains n integers aij (0 ≤ aij ≤ 100) separated by single spaces — the elements of the given matrix. The input limitations for getting 30 points are:    1 ≤ n ≤ 5  The input limitations for getting 100 points are:   1 ≤ n ≤ 101

Print a single integer — the sum of good matrix elements.

NoteIn the first sample all matrix elements will be good. Good elements in the second sample are shown on the figure.

import java.util.*;
public class cf177a {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int[][] v = new int[n][n];
    int[][] w = new int[n][n];
    for(int i=0; i<n; i++)
      for(int j=0; j<n; j++)
        w[i][j] = in.nextInt();
    for(int i=0; i<n; i++)
      v[i][i] = v[n-i-1][i] = 1;
    if(n%2 == 1) for(int i=0; i<n; i++)
      v[i][n/2] = v[n/2][i] = 1;
    int ans = 0;
    for(int i=0; i<n; i++)
      for(int j=0; j<n; j++)
        ans += v[i][j]*w[i][j];
    System.out.println(ans);
  }
}

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

public class Solution {
	public static PrintWriter w = new PrintWriter(System.out);
	public static void main(String args[] ) throws Exception {
		Reader in = new Reader();
		int n = in.nextInt();
		int[][] arr = in.next2dIntArray(n,n);
		int sum = 0;
		int mid = n/2;
		for (int i=0; i<n; i++)
			sum += arr[i][i] + arr[mid][i] + arr[i][mid] + arr[i][n-i-1];
		sum -= (3*arr[mid][mid]);
		w.println(sum);
		w.flush();
		return;
	}
}

class Reader {
	final private int BUFFER_SIZE = 1 << 16;
	private DataInputStream din;
	private byte[] buffer;
	private int bufferPointer, bytesRead;

	public Reader() {
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}
	public String nextLine() throws IOException {
		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 next() throws IOException {
		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 int nextInt() throws IOException {
		int ret = 0;
		byte c = read();
		while(c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if(neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}
	public int[] nextIntArray(int n) throws IOException {
		int a[] = new int[n];
		for(int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}
	public int[][] next2dIntArray(int n, int m) throws IOException {
		int a[][] = new int[n][m];
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				a[i][j] = nextInt();
		return a;
	}
	public char nextChar() throws IOException {
		return next().charAt(0);
	}
	public long nextLong() throws IOException {
		long ret = 0;
		byte c = read();
		while(c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if(neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}
	public double nextDouble() throws IOException {
		double ret = 0, div = 1;
		byte c = read();
		while(c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if(neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while((c = read()) >= '0' && c <= '9');
		if (c == '.') {
			while((c = read()) >= '0' && c <= '9') {
				ret += (c - '0') / (div *= 10);
			}
		}
		if(neg)
			return -ret;
		return ret;
	}
	private void fillBuffer() throws IOException {
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if(bytesRead == -1)
			buffer[0] = -1;
	}
	private byte read() throws IOException {
		if(bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}
	public void close() throws IOException {
		if(din == null)
			return;
		din.close();
	}
	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

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

public class P177A {

  public PrintWriter run() {
    int n = sc.nextInt();
    int sum = 0;

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        int a = sc.nextInt();
        if ((i == j) || (i == (n - j  - 1)) ||
            (i == ((n - 1) / 2)) || (j == ((n - 1) / 2))) {
          sum += a;
        }
      }
    }

    pw.println(sum);

    return pw;
  }

  private Scanner sc = new Scanner(new BufferedInputStream(System.in));
  private PrintWriter pw = new PrintWriter(new BufferedOutputStream(System.out));

  public static void main(String... args) throws Exception {
    new P177A().run().close();
  }
}

import java.util.Scanner;

public class GoodMatrixElements {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int arr[][] = new int[n][n];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                arr[i][j] = sc.nextInt();
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += arr[i][(n - 1) / 2];
            sum += arr[(n - 1) / 2][i];
            sum += arr[i][i];
            sum += arr[n - i-1][i];
        }
        System.out.println(sum - 3 * arr[(n - 1) / 2][(n - 1) / 2]);
    }
}

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

public class GoodMatrixElements {
	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			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;
		}
	}

	public static void main(String[] args) {
		FastReader scan = new FastReader();

		int n = scan.nextInt();

		int[][] matrix = new int[n][n];

		for(int i = 0; i < matrix.length; i++) {
			for(int j = 0; j < matrix[i].length; j++) {
				matrix[i][j] = scan.nextInt();
			}
		}

		int sum = 0;

		for(int i = 0; i < n; i++) {
			sum += matrix[i][i];
			sum += matrix[i][n - i - 1];
			sum += matrix[(n - 1) / 2][i];
			sum += matrix[i][(n - 1) / 2];
		}

		System.out.println(sum - 3 * (matrix[(n - 1) / 2][(n - 1) / 2]));
	}
}

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

		java.util.Scanner scan=new java.util.Scanner(System.in);
		int n=scan.nextInt();
		int [][]arr=new int[n][n];
		for(int i=1;i<=arr.length;i++){
			for(int j=1;j<=arr.length;j++){
				arr[i-1][j-1]=scan.nextInt();
			}
		}
		long sum=0;
		for(int i=1;i<=arr.length;i++){
			sum+=arr[i-1][i-1];
			sum+=arr[i-1][arr.length-i];
		}
		//System.out.println("sum: "+sum);
		for(int i=1;i<=arr.length;i++){
			sum+=arr[arr.length/2][i-1];
			sum+=arr[i-1][arr.length/2];
		}
		//System.out.println("sum: "+sum);
		sum-=3*arr[arr.length/2][arr.length/2];
		System.out.println(sum);
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 *
 * @author utp
 */
public class CodeJ
{
    static class Scanner
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");

		public String nextLine()
		{
			try
			{
				return br.readLine();
			}
			catch(Exception e)
			{
				throw(new RuntimeException());
			}
		}

		public String next()
		{
			while(!st.hasMoreTokens())
			{
				String l = nextLine();
				if(l == null)
					return null;
				st = new StringTokenizer(l);
			}
			return st.nextToken();
		}

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

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

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

		public int[] nextIntArray(int n)
		{
			int[] res = new int[n];
			for(int i = 0; i < res.length; i++)
				res[i] = nextInt();
			return res;
		}

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

		public double[] nextDoubleArray(int n)
		{
			double[] res = new double[n];
			for(int i = 0; i < res.length; i++)
				res[i] = nextDouble();
			return res;
		}
		public void sortIntArray(int[] array)
		{
			Integer[] vals = new Integer[array.length];
			for(int i = 0; i < array.length; i++)
				vals[i] = array[i];
			Arrays.sort(vals);
			for(int i = 0; i < array.length; i++)
				array[i] = vals[i];
		}

		public void sortLongArray(long[] array)
		{
			Long[] vals = new Long[array.length];
			for(int i = 0; i < array.length; i++)
				vals[i] = array[i];
			Arrays.sort(vals);
			for(int i = 0; i < array.length; i++)
				array[i] = vals[i];
		}

		public void sortDoubleArray(double[] array)
		{
			Double[] vals = new Double[array.length];
			for(int i = 0; i < array.length; i++)
				vals[i] = array[i];
			Arrays.sort(vals);
			for(int i = 0; i < array.length; i++)
				array[i] = vals[i];
		}

		public String[] nextStringArray(int n)
		{
			String[] vals = new String[n];
			for(int i = 0; i < n; i++)
				vals[i] = next();
			return vals;
		}

		Integer nextInteger()
		{
			String s = next();
			if(s == null)
				return null;
			return Integer.parseInt(s);
		}

		int[][] nextIntMatrix(int n, int m)
		{
			int[][] ans = new int[n][];
			for(int i = 0; i < n; i++)
				ans[i] = nextIntArray(m);
			return ans;
		}

		static <T> T fill(T arreglo, int val)
		{
			if(arreglo instanceof Object[])
			{
				Object[] a = (Object[]) arreglo;
				for(Object x : a)
					fill(x, val);
			}
			else if(arreglo instanceof int[])
				Arrays.fill((int[]) arreglo, val);
			else if(arreglo instanceof double[])
				Arrays.fill((double[]) arreglo, val);
			else if(arreglo instanceof long[])
				Arrays.fill((long[]) arreglo, val);
			return arreglo;
		}

		<T> T[] nextObjectArray(Class <T> clazz, int size)
		{
			@SuppressWarnings("unchecked")
			T[] result = (T[]) java.lang.reflect.Array.newInstance(clazz, size);
			try
			{
				Constructor <T> constructor = clazz.getConstructor(Scanner.class, Integer.TYPE);
				for(int i = 0; i < result.length; i++)
					result[i] = constructor.newInstance(this, i);
				return result;
			}
			catch(Exception e)
			{
				throw new RuntimeException(e);
			}
		}
	}

    public static void main(String[] args)
    {
        Scanner sc = new Scanner();
        int n = sc.nextInt();
        int[][] matrix = sc.nextIntMatrix(n, n);
        boolean[][] esta = new boolean[n][n];
        for(int i = 0; i < n; i++)
        {
            esta[i][i] = true;
            esta[n - i - 1][i] = true;
            esta[n / 2][i] = true;
            esta[i][n / 2] = true;
        }
        int i = 2;
        int j = 0;
        while(i < n && j < n)
        {
            esta[i][j] = true;
            i++;
            j++;
        }
        i = 0;
        j = 2;
        while(i < n && j < n)
        {
            esta[i][j] = true;
            i++;
            j++;
        }
        int total = 0;
        for(i = 0; i < n; i++)
            for(j = 0; j < n; j++)
                if(esta[i][j])
                    total += matrix[i][j];
        System.out.println(total);
    }
}

import java.util.Scanner;

public class Code177A1 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int[][]matrix=new int[102][102];
        int n,i,j,sum=0;
        n=scanner.nextInt();
        for(i=0;i<n;i++){
            for(j=0;j<n;j++){
                matrix[i][j]=scanner.nextInt();
                if( (i+j)==n-1 || i==j || i==(n-1)/2 ||j==(n-1)/2 ){
                    sum+=matrix[i][j];
                }
            }
        }

        System.out.println(sum);
    }
}

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

public class Task177A {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		public static void main(InputStream is, OutputStream os)
				throws NumberFormatException, IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner sc = new Scanner(is);

			int n = sc.nextInt();

			int a[][] = new int[n][];
			for (int i = 0; i < n; i++) {
				a[i] = new int[n];
			}

			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					a[i][j] = sc.nextInt();
				}
			}

			int retVal = 0;

			for (int i = 0; i < n; i++) {
				retVal += a[i][i];
				retVal += a[i][n - i - 1];
				retVal += a[i][n / 2];
				retVal += a[n / 2][i];
			}

			retVal -= 3 * a[n / 2][n / 2];

			pw.print(retVal);
			pw.flush();
			sc.close();
		}
	}

}

import java.util.*;
public class Main{
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int a[][] = new int[n][n];
		for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		a[i][j]=in.nextInt();
		int mid = (n-1)/2;
		int ans  = 0;
		for(int i=0;i<n;i++)
		if(i!=mid)
		ans+=a[mid][i]+a[i][mid];
		for(int i=0;i<n;i++){
		if(i!=mid){
			ans+=a[i][i]+a[i][n-i-1];
		}
		}
		ans+=a[mid][mid];
		System.out.print(ans);
	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A {

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        //  PrintWriter out = new PrintWriter(new FileOutputStream(new File("output.txt")));
        int n = in.nextInt();
        int [][]data = new int[n][n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                data[i][j] = in.nextInt();
            }
        }
        long total = 0;
        for(int i = 0; i < n; i++){
            total += data[i][i];
            total += data[n - i - 1][i];
            total += data[i][n/2];
            total += data[n/2][i];
        }
        total -= 3*data[n/2][n/2];
        out.println(total);
        out.close();
    }

    static double dist(Point a, Point b) {
        long total = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
        return Math.sqrt(total);
    }

    static class Point {

        int x, y;

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

        }
    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        void update(int index, int val) {
            // System.out.println("UPDATE INDEX " + index);
            while (index < data.length) {
                data[index] += val;
                index += index & (-index);

                //    System.out.println("NEXT " +index);
            }
        }

        int get(int index) {
            //  System.out.println("GET INDEX " + index);
            int result = 0;
            while (index > 0) {
                result += data[index];
                index -= index & (-index);
                // System.out.println("BACK " + index);
            }
            return result;
        }
    }

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

    static int pow(int a, int b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        int val = pow(a, b / 2);
        if (b % 2 == 0) {

            return val * val;
        } else {
            return val * val * a;
        }
    }

//    static Point intersect(Point a, Point b, Point c) {
//        double D = cross(a, b);
//        if (D != 0) {
//            return new Point(cross(c, b) / D, cross(a, c) / D);
//        }
//        return null;
//    }
//
//    static Point convert(Point a, double angle) {
//        double x = a.x * cos(angle) - a.y * sin(angle);
//        double y = a.x * sin(angle) + a.y * cos(angle);
//        return new Point(x, y);
//    }
//    static Point minus(Point a, Point b) {
//        return new Point(a.x - b.x, a.y - b.y);
//    }
//
//    static Point add(Point a, Point b) {
//        return new Point(a.x + b.x, a.y + b.y);
//    }
//
//    static double cross(Point a, Point b) {
//        return a.x * b.y - a.y * b.x;
//
//
//    }
//
//    static class Point {
//
//        int x, y;
//
//        Point(int x, int y) {
//            this.x = x;
//            this.y = y;
//        }
//
//        @Override
//        public String toString() {
//            return "Point: " + x + " " + y;
//        }
//    }
    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            // br = new BufferedReader(new FileReader(new File("input.txt")));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

    import java.util.Scanner;
import java.util.Scanner;

    public class A2 {

        public static void main(String[] args) {
            Scanner in=new Scanner(System.in);
            int i,j,k,n,f;
            long s;
            int[][] a=new int[1000][1000];
            n=in.nextInt();
            for(i=0;i<n;i++){
                for(j=0;j<n;j++){
                    a[i][j]=in.nextInt();
                }
            }
            s=0;
            for(i=0;i<n;i++){
                s+=a[i][i];
                a[i][i]=0;
            }
            j=n-1;
            for(i=0;i<n;i++){
                s+=a[i][j];
                a[i][j]=0;
                j--;
            }
            for(i=0;i<n;i++){
                s+=a[i][((n-1)/2)];
                a[i][((n-1)/2)]=0;
            }
            for(i=0;i<n;i++){
                s+=a[((n-1)/2)][i];
                a[((n-1)/2)][i]=0;
            }
            System.out.println(s);
        }

    }

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

public class Main {
  BufferedReader br;

  public void go() throws Exception {
    br = new BufferedReader(new InputStreamReader(System.in));
    String s = br.readLine();
    int n = Integer.parseInt(s);
    int[][] a = new int[n][n];
    for (int i = 0; i < n; i++) {
      s = br.readLine();
      String[] ss = s.split(" ");
      for (int j = 0; j < n; j++)
        a[i][j] = Integer.parseInt(ss[j]);
    }

    int mid = n >> 1;
    int ac = 0;
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        if (i == j || i == mid || j == mid || i == n - 1 - j)
          ac += a[i][j];

    System.out.println(ac);
  }

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

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

public class test
{

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

	PrintWriter out = null;

	void run()
	{
		Scanner in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		int n = in.nextInt();
		int[][] mat = new int[n][n];
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				mat[i][j] = in.nextInt();

		int total = 0;

		int mid = n / 2;

		for (int i = 0; i < n; i++)
		{
			total += mat[i][mid];
			total += mat[mid][i];
			total += mat[i][i];
			total += mat[i][n - i - 1];
		}

		total -= mat[mid][mid] * 3;
		out.println(total);
		out.close();
	}

}

import java.io.StreamTokenizer;
import java.util.Scanner;

public class A {
    static StreamTokenizer st;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int [][]a = new int [n+1][n+1];
        boolean [][]f = new boolean [n+1][n+1];
        for (int i = 1; i <=n; i++) {
            for (int j = 1; j <=n; j++) {
                a[i][j] =  sc.nextInt();
            }
        }
        int cnt = n;
        int ans = 0;
        for (int i = 1; i <=n; i++) {
            if (!f[i][cnt]){
                ans += a[i][cnt];
                f[i][cnt] = true;
                cnt--;
            }
            if (!f[i][i]){
                ans += a[i][i];
                f[i][i] = true;
            }
        }
        int id = n/2+1;
        for (int i = 1; i <=n; i++) {
            if (!f[i][id]){
                ans += a[i][id];
                f[i][id] = true;
            }
            if (!f[id][i]){
                ans += a[id][i];
                f[id][i] = true;
            }
        }
        System.out.println(ans);
    }
}

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

public class MatrixGoodElements {
    public static void main(String[] args) {
        solve();
    }

    public static void solve() {
        BufferedReader br = null;
        InputStreamReader is = null;
        is = new InputStreamReader(System.in);
        br = new BufferedReader(is);
        try {
            int dimension = Integer.valueOf(br.readLine());
            Integer[][] matrix = new Integer[dimension][dimension];
            for (int row = 0; row < dimension; ++row) {
                StringTokenizer strTokenizer = new StringTokenizer(br.readLine(), " ");
                for (int column = 0; column < dimension; ++column) {
                    matrix[row][column] = Integer.valueOf(strTokenizer.nextToken());
                }
            }
            int res = 0;
            int middle = dimension / 2;
            for (int index = 0; index < dimension; ++index) {
                res += matrix[index][index];
                res += matrix[dimension - index - 1][index];
                res += matrix[middle][index];
                res += matrix[index][middle];
            }
            res -= 3 * matrix[middle][middle];
            System.out.println(res);
            } catch (Exception e) {
            e.printStackTrace();
        }
        if (is != null)
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        if (br != null)
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }

    static int getNod(int num1, int num2) {
        int n = num1 % num2;
        num1 = num2;
        num2 = n;
        if (n > 0)
            return getNod(num1, num2);
        else
            return num1;
    }

}

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

public class Main implements Runnable {

	public void solve() throws IOException {
		int N = nextInt();
                int[][] a = new int[N][N];
                for(int i = 0; i < N; i++){
                        for(int j = 0; j < N; j++) a[i][j] = nextInt();
                }

                int ans = 0;
                for(int i = 0; i < N; i++) ans += a[i][i];
                for(int i = 0; i < N; i++) ans += a[i][N - i - 1];
                for(int i = 0; i < N; i++) ans += a[N/2][i];
                for(int i = 0; i < N; i++) ans += a[i][N/2];

                ans -= 3 * a[N/2][N/2];

                System.out.println(ans);
	}

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

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

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

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

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

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

	BufferedReader in;
	StringTokenizer tok;
}

import java.io.*;
import java.util.*;
import java.lang.Math.*;
public class good
{
     public static void main(String args[])throws Exception
     {
         Scanner in=new Scanner(System.in);
         //BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         //BufferedReader br = new BufferedReader(new FileReader("good.in"));
         //PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("good.out")));
         PrintWriter pw = new PrintWriter(System.out);
         //StringTokenizer st;
         int n=in.nextInt();
         int i,j,k,l;
         int a[][]=new int[n][n];
         if(n==1)
         {
         pw.println(in.nextInt());
         pw.flush();
         System.exit(0);
        }
         for(i=0;i<n;i++)
         {
             for(j=0;j<n;j++)
             a[i][j]=in.nextInt();
         }
         int sum=0;
         for(j=0;j<n;j++)
         {
             sum+=a[n/2][j]+a[j][n/2]+a[j][j]+a[j][n-1-j];
            }
         pw.println(sum-3*(a[n/2][n/2]));
         pw.flush();
     }
}

import java.util.Scanner;

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int matrix[][] = new int[N][N];

        for(int i = 0; i < N; i++){
            for(int j = 0; j < N; j++){
                matrix[i][j] = sc.nextInt();
            }
        }

        System.out.println(calc(matrix, N));

    }

    static int calc(int[][] matrix, int N){
        int value = 0;
        int middle = N/2;
        for(int i = 0; i < N; i++){
            value += matrix[i][i];
        }

        for(int i = 0; i < N; i++){
            value += matrix[i][N - i - 1];
        }
        value -= matrix[middle][middle];

        for(int i = 0; i < N; i++){
            value += matrix[middle][i];
        }
        value -= matrix[middle][middle];

        for(int i = 0; i < N; i++){
            value += matrix[i][middle];
        }
        value -= matrix[middle][middle];

        return value;
    }
}

import java.util.Scanner;

public class A1 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int units[][] = new int[n][n];
        int sum = 0;
        //in.next();
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++){
                int tmp = in.nextInt();
                if ((i == j) || (i == (n-j+1)) || (i == (n/2 + 1)) || (j == (n/2 + 1)))
                    sum += tmp;
            }

        System.out.println(sum);
    }
}

import java.util.Scanner;

public class random {
	public static void main (String[] args) {
		Scanner s = new Scanner(System.in);
		int num = s.nextInt();
		int[][] array = new int[num][num];

		for (int x = 0; x < num; x ++) {
			for (int y = 0; y < num; y ++) {
				int n = s.nextInt();
				array[x][y] = n;
			}
		}

		int sum = 0;
		for (int x = 0; x < num; x ++) {
			sum += array[x][x];
			sum += array[x][num - 1 - x];
			sum += array[x][num/2];
			sum += array[num/2][x];
		}

		sum -= (array[num/2][num/2] * 3);
		System.out.print(sum);
	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner stdin = new Scanner(System.in);
		int n = stdin.nextInt();

		int[][] array = new int[n][n];

		for(int i=0; i< n; ++i){
			for(int j=0; j< n; ++j)
			{
				array[i][j] = stdin.nextInt();
			}

		}

		long sum=0;

		int midl = (n-1)/2;

		//середина вертикаль
		for(int j=0; j< n; ++j)
		{
			sum+=array[j][midl];
		}

		//середина гор
		for(int j=0; j< n; ++j)
		{
			sum+=array[midl][j];
		}
		sum-=array[midl][midl];

		for(int j=0; j< n; ++j)
		{
			sum+=array[j][j];
		}
		sum-=array[midl][midl];

		for(int j=0; j< n; ++j)
		{
			sum+=array[j][n-1-j];
		}
		sum-=array[midl][midl];

		System.out.print(sum);
	}

}

import java.util.*;
public class Main{

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input=new Scanner(System.in);
		while(input.hasNext()){
			int sum=0;
			int size=input.nextInt();
			Vertex [][]array=new Vertex [size][size];
			for(int i=0;i<size;i++){
				for(int j=0;j<size;j++){
					array[i][j]=new Vertex(input.nextInt());
					if(i==j){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
					if(i+j==size-1&&!array[i][j].judge){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
					if(i==(size-1)/2&&!array[i][j].judge){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
					if(j==(size-1)/2&&!array[i][j].judge){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
				}
			}
			System.out.println(sum);
		}
	}

}
class Vertex{
	boolean judge=false;
	int value;
	Vertex(int value){
		this.value=value;
	}
}

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

public class Main {
    public void solve( ) throws Throwable {
        int n = in.nextInt( ), sum = 0;
        //int mat[ ][ ] = new int[ n ][ n ];
        //boolean vis[ ][ ] = new boolean[ n ][ n ];
        for ( int i = 0; i < n; ++i ) {
            for ( int j = 0; j < n; ++j ) {
                int cur = in.nextInt( );
                if ( i == j || i + j == n - 1 || i ==  n / 2 || j ==  n / 2 ) {
                    sum += cur;
                } else {
                    //debug( i, j );
                }
            }
        }
        out.println( sum );
    }

    public void run( ) {
        in = new FastScanner( System.in );
        out = new PrintWriter( new PrintStream( System.out ), true );

        try {
            solve( );
            out.close( );
            System.exit( 0 );
        } catch( Throwable e ) {
            e.printStackTrace( );
            System.exit( -1 );
        }
    }

    public void debug( Object...os ) {
        System.err.println( Arrays.deepToString( os ) );
    }

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

    private FastScanner in;
    private PrintWriter out;

    private static class FastScanner {
        private int charsRead;
        private int currentRead;
        private byte buffer[ ] = new byte[ 0x1000 ];
        private InputStream reader;

        public FastScanner( InputStream in ) {
            reader = in;
        }

        public int read( ) {
            if ( charsRead == -1 ) {
                throw  new InputMismatchException( );
            }

            if ( currentRead >= charsRead ) {
                currentRead = 0;
                try {
                    charsRead = reader.read( buffer );

                } catch( IOException e ) {
                    throw new InputMismatchException(  );
                }

                if ( charsRead <= 0 ) {
                    return -1;
                }
            }

            return buffer[ currentRead++ ];
        }

        public int nextInt( ) {
            int c = read( );

            while ( isWhitespace( c ) ) {
                c = read( );
            }

            if ( c == -1 ) {
                throw new NullPointerException( );
            }

            if ( c != '-' && !( c >= '0' && c <= '9' ) ) {
                throw new InputMismatchException( );
            }

            int sign = c == '-' ? -1 : 1;
            if ( sign == -1 ) {
                c = read( );
            }

            if ( c == -1 || !( c >= '0' && c <= '9' ) ) {
                throw new InputMismatchException( );
            }

            int ans = 0;
            while ( !isWhitespace( c )  && c != -1 ) {
                if ( !( c >= '0' && c <= '9' ) ) {
                    throw  new InputMismatchException( );
                }
                int num = c - '0';
                ans = ans * 10 + num;
                c = read( );
            }

            return ans * sign;
        }

        public long nextLong( ) {
            int c = read( );

            while ( isWhitespace( c ) ) {
                c = read( );
            }

            if ( c == -1 ) {
                throw new NullPointerException( );
            }

            if ( c != '-' && !( c >= '0' && c <= '9' ) ) {
                throw new InputMismatchException( );
            }

            int sign = c == '-' ? -1 : 1;
            if ( sign == -1 ) {
                c = read( );
            }

            if ( c == -1 || !( c >= '0' && c <= '9' ) ) {
                throw new InputMismatchException( );
            }

            long ans = 0;
            while ( !isWhitespace( c )  && c != -1 ) {
                if ( !( c >= '0' && c <= '9' ) ) {
                    throw  new InputMismatchException( );
                }
                int num = c - '0';
                ans = ans * 10 + num;
                c = read( );
            }

            return ans * sign;
        }

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

        public String next( ) {
            int c = read( );
            StringBuffer ans = new StringBuffer( );

            while ( isWhitespace( c ) && c != -1 ) {
                c  = read( );
            }

            if ( c == -1 ) {
                return null;
            }

            while ( !isWhitespace( c ) && c != -1 ) {
                ans.appendCodePoint( c );
                c = read( );
            }

            return ans.toString( );

        }

        public String nextLine( ) {
            String ans = nextLine0( );

            while ( ans.trim( ).length( ) == 0 ) {
                ans = nextLine0( );
            }

            return ans;
        }

        private String nextLine0( ) {
            int c = read( );
            if ( c == -1 ) {
                return null;
            }
            StringBuffer ans = new StringBuffer( );
            while ( c != '\n' && c != '\r' && c != -1 ) {
                ans.appendCodePoint( c );
                c = read( );
            }

            return ans.toString( );

        }

        public double nextDouble( ) {
            int c = read( );
            while ( isWhitespace( c ) ) {
                c = read( );
            }

            if ( c == -1 ) {
                throw new NullPointerException( );
            }

            if ( c != '.' && c != '-' && !( c >= '0' && c <= '9' ) ) {
                throw new InputMismatchException( );
            }

            int sign = c == '-' ? -1 : 1;
            if ( c == '-' ) {
                c = read( );
            }
            double ans = 0;
            while ( c != -1 && c != '.' && !isWhitespace( c ) ) {
                if ( !( c >= '0' && c <= '9' ) ) {
                    throw new InputMismatchException( );
                }

                int num = c - '0';
                ans = ans * 10.0 + num;
                c = read( );
            }

            if ( !isWhitespace( c ) && c != -1 && c != '.' ) {
                throw new InputMismatchException( );
            }

            double pow10 = 1.0;

            if ( c == '.' ) {
                c = read( );
            }

            while ( !isWhitespace( c ) && c != -1 ) {
                pow10 *= 10.0;

                if ( !( c >= '0' && c <= '9' ) ) {
                    throw new InputMismatchException( );
                }
                int num = c - '0';
                ans = ans * 10.0 + num;
                c = read( );
            }

            return ans * sign / pow10;
        }
    }

}

import java.util.*;
public class ABA {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N =  sc.nextInt();
		int[][] array = new int[N][N];
		boolean[][] B = new boolean[N][N];
		long ans = 0;
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				array[a][b]=sc.nextInt();
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==b){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==(N-1-b)){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			//for(int b=0;b<N;b++){
			int b = N/2;

					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}

		for(int a=0;a<N;a++){
		//for(int b=0;b<N;b++){
		int b = N/2;

				if(!B[b][a]){
					B[b][a]=true;
					ans+=array[b][a];
				}
			}

		System.out.println(ans);

	}

}

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

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

class TaskA1 {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
        int N = in.nextInt();
        int[][] mat = new int[N][N];
        for (int i=0; i<N; i++) for (int j=0; j<N; j++) mat[i][j] = in.nextInt();
        boolean[][] matbool = new boolean[N][N];
        for (int i=0; i<N; i++) Arrays.fill(matbool[i], false);
	    for (int i=0; i<N; i++) matbool[i][i] = true;
        for (int i=0, j=N-1; i<N; i++, j--) matbool[i][j] = true;
        int c = (N-1)/2;
        for (int i=0; i<N; i++) { matbool[i][c] = true; matbool[c][i] = true; }
        int sum = 0;
        for (int i=0; i<N; i++) for (int j=0; j<N; j++) if (matbool[i][j]) sum += mat[i][j];
        out.println(sum);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.Collections;
import java.util.StringTokenizer;

public class Codeforces177A {

	public static void main(String[] args) {
		FastScanner sc=new FastScanner();
		int n = sc.nextInt();
		int a[][] = new int[n][n];
		for(int i =0 ;i < n ;i++) {
			a[i] = sc.readArray(n);
		}int sum = 0;
		for(int i = 0; i <n ;i++) {
			sum+=a[i][i];
			a[i][i] = 0;
		}
		for(int i = 0 , j = n-1 ; i < n ; i++,j--) {
			sum += a[i][j];
			a[i][j] = 0;
		}
		for(int i =0 ;i < n ;i++) {
			sum += a[(n-1)/2][i] ;
			a[(n-1)/2][i] =0;
		}for(int i =0 ; i < n ; i++) {
			sum += a[i][(n-1)/2];
			a[i][(n-1)/2] = 0;
		}
		System.out.println(sum);
	}

	public void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");

		public String next() {
			while (!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());
		}

		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
	}

}

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

public class Main
{
        // sosni huica
	public static void main ( String[] args ) throws IOException
	{
	        Scanner in=new Scanner(System.in);
		PrintWriter out=new PrintWriter(System.out);
		int n=in.nextInt();
		int[][] matrix=new int[n][n];
		for (int i=0;i<n;++i)
			for (int j=0;j<n;++j)
				matrix[i][j]=in.nextInt();
		int sum=0;
		for (int i=0;i<n;++i)
			for (int j=0;j<n;++j)
				if (i==j || i+j==n-1 || i==n/2 || j==n/2)
					sum+=matrix[i][j];
		out.print(sum);
		out.close();
	}
}

import java.util.Scanner;
public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();

		boolean a[][] = new boolean[n][n];
		int b[][] = new int[n][n];
		for(int i = 0; i < n;i++)
			for(int j = 0; j < n;j++)
				b[i][j] = input.nextInt();

		int sum = 0;
		//main diagonal
		for(int i = 0; i < n;i++){
			if(a[i][i] == false){
				sum += b[i][i];
				a[i][i] = true;
			}
		}

		//secondary diagonal
		for(int i = 0; i < n;i++){
			if(a[i][(n-i)-1] == false){
				sum += b[i][(n-i)-1];
				a[i][(n-i)-1] = true;
			}
		}

		//middle row
		int mid = n/2;
		for(int i = 0; i < n;i++){
			if(a[mid][i] == false){
				sum += b[mid][i];
				a[mid][i] = true;
			}
		}

		//middle column
		for(int i = 0; i < n;i++){
			if(a[i][mid] == false){
				sum += b[i][mid];
				a[i][mid] = true;
			}
		}
		System.out.println(sum);
	}
}

import java.util.Scanner;

public class A177 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] a = new int[n][n];
        boolean[][] u = new boolean[n][n];
        for (int i = 0 ; i < n ; i++)
            for (int j = 0 ; j < n ; j++) {
                a[i][j] = in.nextInt();
                u[i][j] = false;
            }
        int res = 0;
        for (int i = 0 ; i < n ; i++) {
            res += a[i][i];
            u[i][i] = true;
        }
        for (int i = 0 ; i < n ; i++)
            if (!u[i][n - 1 - i]) {
                res += a[i][n - i - 1];
                u[i][n - i - 1] = true;
            }
        int m = n / 2;
        for (int i = 0 ; i < n ; i++)
            if (!u[m][i]) {
                res += a[m][i];
                u[m][i] = true;
            }
        for (int i = 0 ; i < n ; i++)
            if (!u[i][m]) {
                res += a[i][m];
                u[i][m] = true;
            }
        System.out.println(res);
    }
}

import java.util.Scanner;

public class A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][]a = new int[n+1][n+1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                a[i][j] = sc.nextInt();
            }
        }
        int sum = 0;
        boolean[][]used = new boolean[n+1][n+1];
        for (int i = 1; i <= n; i++) {
            if (!used[i][i]) {
                used[i][i] = true;
                sum += a[i][i];
            }
            if (!used[i][n+1-i]) {
                used[i][n+1-i] = true;
                sum += a[i][n+1-i];
            }
            if (!used[i][(n+1)/2]) {
                used[i][(n+1)/2] = true;
                sum += a[i][(n+1)/2];
            }
            if (!used[(n+1)/2][i]) {
                used[(n+1)/2][i] = true;
                sum += a[(n+1)/2][i];
            }
        }
        System.out.println(sum);
    }

}

import java.io.*;

import java.util.*;

public class CodeForces {

	public void solve() throws IOException {
		int n = nextInt();
		int arr[][] = new int[n][n];
		for (int i = 0, l = arr.length; i < l; i++) {
			for (int j = 0, m = arr.length; j < m; j++) {
				arr[i][j] = nextInt();
			}
		}
		int sum = 0;
		if(n==1) {
			sum=arr[0][0];
		} else {
		for (int i = 0, l = arr.length; i < l; i++) {
			sum+=arr[i][i];
			sum+=arr[l-i-1][i];
			sum+=arr[n/2][i];
			sum+=arr[i][n/2];
		}
		sum-=3*arr[n/2][n/2];
		}
		out.print(sum);

	}

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

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter(new BufferedWriter(new FileWriter(
						"output.txt")));
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;
			// long t=new Date().getTime();
			solve();
			// writer.println(t-new Date().getTime());
			reader.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(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

import java.util.*;
public class Main{
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int a[][] = new int[n][n];
		for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		a[i][j]=in.nextInt();
		int mid = (n-1)/2;
		int ans  = 0;
		for(int i=0;i<n;i++)
		if(i!=mid)
		ans+=a[mid][i]+a[i][mid];
		for(int i=0;i<n;i++){
		if(i!=mid){
			ans+=a[i][i]+a[i][n-i-1];
		}
		}
		ans+=a[mid][mid];
		System.out.print(ans);
	}
}

import java.util.Scanner;

public class A1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int result = 0;
		for(int y = 0; y < n; y++)
			for(int x = 0; x < n; x++)
			{
				int v = sc.nextInt();
				if(isGood(x,y,n))
					result += v;
			}
		System.out.println(result);
	}

	private static boolean isGood(int x, int y, int n) {
		if(x == y) return true;
		if(x == n - y - 1) return true;
		if(2*x + 1 == n) return true;
		if(2*y + 1 == n) return true;
		return false;
	}

}

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

public class Codeforces {

	public static void main(String[] args) throws Exception
	{
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int a[][] = new int[n+1][n+1];
		for (int i = 1; i <= n; ++i)
			for (int j = 1; j <= n; ++j)
				a[i][j] = in.nextInt();
		in.close();
		int sum = 0;
		for (int i = 1; i <=n; ++i)
			sum += a[i][i] + a[i][n-i+1] + a[i][(n+1)/2]+a[(n+1)/2][i];
		sum -= 3*a[(n+1)/2][(n+1)/2];
		System.out.println(sum);
	}
}

import java.io.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskB solver = new TaskB();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskB {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int t = 1;
			for (int tt = 0; tt < t; tt++) {
				int n = in.nextInt();
				int arr[][] = new int[n][n];
				int sum = 0;
				for (int i = 0; i < arr.length; i++) {
					for (int j = 0; j < n; j++) {
						arr[i][j] = in.nextInt();
						if (i == j || (j == (n / 2)) || i == n / 2 || j == n - i - 1)
							sum = sum + arr[i][j];
					}
				}
				out.println(sum);
			}

		}
	}

	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());
		}

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

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

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

public class A implements Runnable {

	private void Solution() throws IOException {
		int n = nextInt();
		int[][] mas = new int[n][n];
		boolean[][] used = new boolean[n][n];
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				mas[i][j] = nextInt();
		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum += mas[i][i];
			used[i][i] = true;
		}
		for (int i = 0; i < n; i++) {
			if (!used[i][n - i - 1]) {
				sum += mas[i][n - i - 1];
				used[i][n - i - 1] = true;
			}
		}
		for (int i = 0; i < n; i++) {
			if (!used[i][n / 2]) {
				sum += mas[i][n / 2];
				used[i][n / 2] = true;
			}
		}
		for (int i = 0; i < n; i++) {
			if (!used[n / 2][i]) {
				sum += mas[n / 2][i];
				used[n / 2][i] = true;
			}
		}
		print(sum);
	}

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

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tokenizer;

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			Solution();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(0);
		}
	}

	void print(Object... o) {
		for (int i = 0; i < o.length; i++) {
			if (i != 0)
				out.print(" ");
			out.print(o[i]);
		}
	}

	void println(Object... o) {
		for (int i = 0; i < o.length; i++) {
			if (i != 0)
				print(" ");
			print(o[i]);
		}
		print("\n");
	}

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

	long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

	String nextLine() throws IOException {
		return in.readLine();
	}

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

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

public class Main {
   private static IO io;

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

   private void run() throws IOException {
       io = new IO(System.getProperty("ONLINE_JUDGE")!=null);
       solve();
       io.flush();
   }

   private void solve() throws IOException {
       int n = io.nI(); long r = 0;
       for(int i = 0; i<n; i++)
           for(int j = 0; j<n; j++){
               if(i==j || i==n-j-1 || i==n/2 || j==n/2)r+=io.nI();else io.nI();
           }
       io.wln(r);
   }//2.2250738585072012e-308

   @SuppressWarnings("unused")
   private class IO{
       StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
       public IO(boolean oj) throws IOException{
           Locale.setDefault(Locale.US);
           reader = oj ? new InputStreamReader(System.in) : new FileReader("input.txt");
           writer = oj ? new OutputStreamWriter(System.out) : new FileWriter("output.txt");
           br = new BufferedReader(reader);
           in = new StreamTokenizer(br);
           out = new PrintWriter(writer);
       }
       public void wln(){out.println();}
       public void wln(int arg){out.println(arg);}
       public void wln(long arg){out.println(arg);}
       public void wln(double arg){out.println(arg);}
       public void wln(String arg){out.println(arg);}
       public void wln(boolean arg){out.println(arg);}
       public void wln(char arg){out.println(arg);}
       public void wln(float arg){out.println(arg);}
       public void wln(Object arg){out.println(arg);}
       public void w(int arg){out.print(arg);}
       public void w(long arg){out.print(arg);}
       public void w(double arg){out.print(arg);}
       public void w(String arg){out.print(arg);}
       public void w(boolean arg){out.print(arg);}
       public void w(char arg){out.print(arg);}
       public void w(float arg){out.print(arg);}
       public void w(Object arg){out.print(arg);}
       public void wf(String format, Object...args){out.printf(format, args);}
       public void flush(){out.flush();}
       public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
       public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
       public String nS() throws IOException {in.nextToken(); return in.sval;}
       public double nD() throws IOException {in.nextToken(); return in.nval;}
       public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
       public void wc(char...a){for(char c : a){in.ordinaryChar(c);in.wordChars(c, c);}}
       public void wc(char c1, char c2){in.ordinaryChars(c1, c2); in.wordChars(c1, c2);}
   }
}

//package javaapplication262;
import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int arr[][] = new int[n][n];
        for(int i=0; i<n; i++) {
            for(int j=0; j<n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int sum = 0;
        for(int i=0; i<n; i++) {
            sum += arr[i][i];
        }
        for(int i=0; i<n; i++) {
            sum += arr[n/2][i];
        }
        for(int i=0; i<n; i++) {
            sum += arr[i][n/2];
        }
        for(int i=0; i<n; i++) {
            sum += arr[i][n-i-1];
        }
        int middle = arr[n/2][n/2];
        System.out.println(sum - 3*middle);
    }
}

import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class Start {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

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

    public static void mergeSort(int[] a) {
        mergeSort(a, 0, a.length - 1);
    }

    private static void mergeSort(int[] a, int levtIndex, int rightIndex) {
        final int MAGIC_VALUE = 50;
        if (levtIndex < rightIndex) {
            if (rightIndex - levtIndex <= MAGIC_VALUE) {
                insertionSort(a, levtIndex, rightIndex);
            } else {
                int middleIndex = (levtIndex + rightIndex) / 2;
                mergeSort(a, levtIndex, middleIndex);
                mergeSort(a, middleIndex + 1, rightIndex);
                merge(a, levtIndex, middleIndex, rightIndex);
            }
        }
    }

    private static void merge(int[] a, int levtIndex, int middleIndex,
            int rightIndex) {
        int length1 = middleIndex - levtIndex + 1;
        int length2 = rightIndex - middleIndex;
        int[] levtArray = new int[length1];
        int[] rightArray = new int[length2];
        System.arraycopy(a, levtIndex, levtArray, 0, length1);
        System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
        for (int k = levtIndex, i = 0, j = 0; k <= rightIndex; k++) {
            if (i == length1) {
                a[k] = rightArray[j++];
            } else if (j == length2) {
                a[k] = levtArray[i++];
            } else {
                a[k] = levtArray[i] <= rightArray[j] ? levtArray[i++]
                        : rightArray[j++];
            }
        }
    }

    private static void insertionSort(int[] a, int levtIndex, int rightIndex) {
        for (int i = levtIndex + 1; i <= rightIndex; i++) {
            int current = a[i];
            int j = i - 1;
            while (j >= levtIndex && a[j] > current) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = current;
        }
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    class LOL {
        int x;
        int y;

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

    }

    public void solve() throws IOException {

        int n = readInt();
        int [][] d = new int [n][n];
        boolean [][] b = new boolean [n][n];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                d[i][j] = readInt();
            }
        }

        long dioganal = 0;
        long pob = 0;
        long hori = 0;
        long vert = 0;

        for (int i = 0; i < n; i++){
            dioganal += d[i][i];
            b[i][i] = true;
        }

        for (int i = 0; i < n; i++){
            if (b[i][n-1-i]==false){
                pob += d[i][n-1-i];
                b[i][n-1-i] = true;
            }
        }

        for (int i =0; i<n; i++){
            if (b[i][n/2]==false){
                hori += d[i][n/2];
                b[i][n/2] = true;
            }
        }

        for (int i =0; i<n; i++){
            if (b[n/2][i]==false){
                vert += d[n/2][i];
                b[n/2][i] = true;
            }
        }
        out.print(hori+vert+dioganal+pob);

    }
}

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

public class A1 {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		// Scanner sc=new Scanner(System.in);
		 BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		 int n;
		 n=Integer.parseInt(bf.readLine());
		 int[][] su=new int[n][n];
		 String[] b;
         for(int i=0;i<n;i++){
        	b=(bf.readLine()).split(" ");
        	for(int j=0;j<n;j++){
        		su[i][j]=Integer.parseInt(b[j]);
        	}
         }
         int sum = 0;
         for(int i=0;i<n;i++){
        	 for(int j=0;j<n;j++){
        		 if(i==j){
        			 sum+=su[i][j];
        		 }else if(i+j==n-1){
        			 sum+=su[i][j];
        		 }else if((n-1)%2==0){
        			 if(i==(n-1)/2||j==(n-1)/2){
        				 sum+=su[i][j];
        			 }
        		 }else if((n-1)%2!=0){
        			 if(i==(n-1)/2+1||j==(n-1)/2+1||i==(n-1)/2-1||j==(n-1)/2-1){
        				 sum+=su[i][j];
        			 }

        		 }
        	 }
         }
         System.out.println(sum);

	}

}

import java.util.*;
public class Fafa{
    public static void main(String[] args){
        int n,c=0;
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        int[][] ar=new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                    ar[i][j]=sc.nextInt();
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if((i==(n-1)/2)||(i==j))
                    c=c+ar[i][j];
            }
        }
         for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if((i==(n-1)/2)&&i!=j||((i+j)==n-1)&&i!=j)
                    c=c+ar[j][i];
            }
        }
        System.out.println(c);
    }
}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[][] matrix = new int[n][n];
		int sum = 0;

		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				matrix[i][j] = in.nextInt();
			}
			if (i == n / 2) {
				for (int z = 0; z < n; z++) {
					sum += matrix[i][z];
				}
			} else {
				sum += matrix[i][i];
				sum += matrix[i][n/2];
				sum += matrix[i][n-1-i];
			}
		}
		System.out.println(sum);
	}
}

import java.util.*;

public class Solution {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		int[][] a = new int[n][n];
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				a[i][j] = scan.nextInt();
			}
		}
		int sum = 0;
		for(int i = 0; i < n; i++) {
			sum += a[i][i];
			a[i][i] = 0;
		}
		for(int i = 0; i < n; i++) {
			sum += a[i][n-1-i];
			a[i][n-1-i] = 0;
		}
		int middle = n/2;
		for(int i = 0; i < n; i++) {
			sum += a[middle][i];
			a[middle][i] = 0;
		}
		for(int i = 0; i < n; i++) {
			sum += a[i][middle];
			a[i][middle] = 0;
		}
		System.out.println(sum);
	}
}

//Date: Oct 21, 2013
//Time: 11:53:21 AM

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

public class A1_177 implements Runnable {

	public void solve() throws IOException {
		int d1 = 0;
		int d2 = 0;
		int r = 0;
		int c = 0;

		int N = nextInt();
		int[][] a = new int[N][N];
		for(int i = 0; i < N; i++)
			for(int j = 0; j < N; j++)
				a[i][j] = nextInt();

		for(int i = 0; i < N; i++) d1 += a[i][i];
		for(int i = 0; i < N; i++) d2 += a[i][N - i - 1];
		int mid = (N - 1) / 2;
		for(int j = 0; j < N; j++) r += a[mid][j];
		for(int j = 0; j < N; j++) c += a[j][mid];

		if(N % 2 == 0){
			System.out.println( d1 + d2);
		}
		else{
			System.out.println(d1 + d2 + r + c - (3 * a[mid][mid]));
		}

	}

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

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

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

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

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

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

	BufferedReader in;
	StringTokenizer tok;
}
/**
public class A1_177 {

}

*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Formatter;
import java.util.Locale;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * @author edemairy
 */
public class Main {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
//        Scanner scanner = new Scanner(System.in);
        Scanner scanner = new Scanner(System.in);
//        nbTC = readInt(reader);
//        scanner.nextLine();
//        for (int tc = 1; tc <= nbTC; ++tc) {
        StringBuilder result = new StringBuilder();
        result.append(oneTestCase(scanner));
//        result.append('\n');
//        }
        System.out.println(result);
    }

    private static int N;
    private static int[][] map = new int[103][103];

    private static StringBuilder oneTestCase(Scanner scanner) throws IOException {
        Formatter formatter = new Formatter();
        StringBuilder result = new StringBuilder();
        N = scanner.nextInt();
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                map[i][j] = scanner.nextInt();
            }
        }
        long total = 0;
        for (int i = 0; i < N; ++i) {
            total += map[i][i] + map[N - i - 1][i] + map[N / 2][i] + map[i][N / 2];
        }
        total -= 3 * map[N / 2][N / 2];
//        for (int i = 0; i < 5; ++i) {
//            formatter.format("%3d", n[i]);
//        }
//        result.append(formatter.out());
        result.append(total);
        return result;
    }
}

import java.util.Scanner;
public class scratch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int ara[][]=new int[n][n];
        int sum=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                ara[i][j]=scanner.nextInt();
            }
        }
        for(int i=0;i<n;i++)
        {
            for (int j=0;j<n;j++)
            {
                if(i==j)
                {
                    sum+=ara[i][j];
                }
            }
        }
        int x=(n-1)/2;
        for(int i=0;i<n;i++)
        {
            sum+=ara[i][x];
            if(i==x)
            {
                sum-=ara[i][x];
            }
        }
        for(int i=0;i<n;i++)
        {
            sum+=ara[x][i];
            if(i==x)
            {
                sum-=ara[x][i];
            }
        }
        int b=n-1;
        for(int i=0;i<n;i++)
        {
            sum+=ara[i][b];
            if(i==b)
            {
                sum-=ara[i][b];
            }
            b--;
        }
        System.out.println(sum);
        scanner.close();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.io.Writer;
/**
 * Date     : 21.04.2012
 * Time     : 16:48:16
 * Email    : denys.astanin@gmail.com
 */

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

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

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

	StreamTokenizer in;
	Writer writer;
	Reader reader;

	void run() throws IOException {
		boolean oj = System.getProperty("ONLINE_JUDGE") != null;
		reader = oj ? new InputStreamReader(System.in, "ISO-8859-1")
				: new FileReader("input/ie_a.txt");
		writer = new OutputStreamWriter(System.out, "ISO-8859-1");
		in = new StreamTokenizer(new BufferedReader(reader));
		PrintWriter out = new PrintWriter(writer);
		int n = nextInt();
		int sum = 0;
		boolean[][] was = new boolean[n][n];
		int[][] arr = new int[n][n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {

				arr[i][j] = nextInt();
			}
		}

		for (int i = 0; i < n; i++) {
			if (!was[i][i]) {
				sum += arr[i][i];
				was[i][i] = true;
			}
		}
		for (int i = 0; i < n; i++) {
			if (!was[(n - 1) /2][i]) {
				sum += arr[(n - 1) /2][i];
				was[(n - 1) /2][i] = true;
			}
			if (!was[i][(n - 1) /2]) {
				sum += arr[i][(n - 1) /2];
				was[i][(n - 1) /2] = true;
			}
		}
		for (int i = 0; i < n; i++) {
			if (!was[i][arr.length - 1 - i]) {
				sum += arr[i][arr.length - 1 - i];
			}
		}
		out.println(sum);
		out.flush();
		out.close();
	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
import java.util.Scanner;

/**
 *
 * @author yashvi_1902
 */
public class GoodMatrixElements {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum=0;
        int arr[][] = new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                arr[i][j] = sc.nextInt();
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if( i==j || i+j==n-1 || i==(n-1)/2 || j==(n-1)/2){
                   sum += arr[i][j];
                }
            }
        }
        System.out.println(sum);

    }
}

import java.util.Scanner;

public class CF_177A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[][] val = new int[n][n];

		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				val[i][j] = in.nextInt();
			}
		}

		int center = (n - 1) / 2;
		int sum = 0;
		for(int i = 0; i < n; i++) {
			// main diagonal
			sum += val[i][i];

			// secondary diagonal
			sum += val[n-i-1][i];

			// center row
			sum += val[center][i];

			// center column
			sum += val[i][center];
		}

		sum -= 3 * val[center][center];

		System.out.println(sum);
	}

}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }
        int subCount = 0;
        if (n != 1) {
            for (int i = 0; i < matrix.length; i++) {
                subCount += matrix[i][i];
                for (int j = 0; j < n; j++) {
                    if (i == n - j - 1) {
                        subCount += matrix[i][j];
                    }
                }
                subCount += matrix[i][n / 2];
                subCount += matrix[n / 2][i];

            }
            System.out.println(subCount - (3 * matrix[n / 2][n / 2]));

        } else {
            System.out.println(matrix[0][0]);
        }

    }
}

import java.io.*;
import java.util.*;
public class GelMat{
    public static void main(String[] args){
	int n;// size of matrix
	int sumEl=0;
	int El=0;
	int middle=0;
//	System.out.println("Enter the range of matrix, it should be odd");
	Scanner in=new Scanner(System.in);
	n=in.nextInt();
	while ((n%2)==0){
//	    System.out.println("The value should be odd");
	    n=in.nextInt();
	};
	middle=(n-1)/2+1;
	int[][] SqMatrix=new int[n][n];
//	 System.out.println("Enter the matrix element");
	for(int i=1;i<=n;i++){
	    for(int j=1;j<=n;j++){
	     El=in.nextInt();
	     while(!((El>=0)&&(El<=100))){
//	        System.out.println("Range should be between 0 and 100");
	        El=in.nextInt();
	     }
	     if((i==j)||(i==middle)||(j==middle)||(j==(n-i+1))){
	       sumEl+=El;
//	       System.out.println(i+" "+j);
	     }
	    }
	}
	System.out.println(sumEl);

    }
}

import java.util.*;
public class ABA {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N =  sc.nextInt();
		int[][] array = new int[N][N];
		boolean[][] B = new boolean[N][N];
		long ans = 0;
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				array[a][b]=sc.nextInt();
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==b){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==(N-1-b)){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			//for(int b=0;b<N;b++){
			int b = N/2;

					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}

		for(int a=0;a<N;a++){
		//for(int b=0;b<N;b++){
		int b = N/2;

				if(!B[b][a]){
					B[b][a]=true;
					ans+=array[b][a];
				}
			}

		System.out.println(ans);

	}

}

import java.io.*;
import java.util.Scanner;
public class Solution {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[][] a=new int [n][n];
        int sum=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                a[i][j]=in.nextInt();
                if(i==j)
                    sum=sum+a[i][j];
                else if(j!=((n-1)/2)&&i==((n-1)/2))
                    sum=sum+a[i][j];
                else if(i%2==1&&j%2==1&&i!=j)
                    sum=sum+a[i][j];
                 else if(i!=((n-1)/2)&&j==((n-1)/2))
                    sum=sum+a[i][j];
                else if((i==0&&j==n-1)||(j==0&&i==n-1))
                     sum=sum+a[i][j];
            }
        }
        System.out.println(sum);
    }
}

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

public class prob {

    static Scanner sc;
    static PrintWriter pw;
    static int[][] a;
    static int n;

    public static void main(String[] args) {
        sc = new Scanner(System.in);
        pw = new PrintWriter(System.out);
        try{
            n = sc.nextInt();
            a = new int[n][n];
            for(int i = 0; i < n; i++)
                for(int j = 0; j < n; j++)
                    a[i][j] = sc.nextInt();
            if(n == 1) {
                pw.println(a[0][0]);
                return;
            }
            long s = 0;
            for(int i = 0; i < n; i++)
                s += a[i][i] + a[n - i - 1][i] +
                    a[(n - 1) / 2 + (n - 1) % 2][i] + a[i][(n - 1) / 2 + (n - 1) % 2];
            s -= 3 * a[(n - 1) / 2 + (n - 1) % 2][(n - 1) / 2 + (n - 1) % 2];
            pw.println(s);
        }
        finally {
            pw.close();
        }
    }
}

import java.util.Scanner;

public class A
{

    public static void main(String[] args)
    {
        Scanner scn = new Scanner(System.in);
        int n = scn.nextInt();
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++)
        {
            matrix[i] = new int[n];
        }
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                matrix[i][j] = scn.nextInt();
            }
        }
        long sum = 0;
        for (int i = 0; i < n; i++)
        {
            sum += matrix[i][i];
        }
        for (int i = 0; i < n; i++)
        {
            if(i != n-1-i)
                sum += matrix[i][n-1-i];
        }
        for (int i = 0; i < n; i++)
        {
            if(n-1 != 2*i)
                sum += matrix[(n-1)/2][i];
        }
        for (int i = 0; i < n; i++)
        {
            if(n-1 != 2*i)
                sum += matrix[i][(n-1)/2];
        }
        System.out.println(sum);

    }

}

import java.util.Scanner;

public class GoodMatrixElements
{
    public static void main(String [] args)
    {
        Scanner input = new Scanner(System.in);

        int n = input.nextInt(), sum = 0;
        for( int i = 0; i < n; i++ )
        {
            for( int j = 0; j < n; j++ )
            {
                int val = input.nextInt();

                if( i == j || (i + j) == (n - 1) || i == (n / 2) || j == (n / 2) )
                    sum += val;
            }
        }

        System.out.println(sum);
    }
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();
   int c=0,m;
   m=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==j||i==m||j==m||i+j==(n-1))
           c+=arr[i][j];
           }
   }
       System.out.print(c);

}
}

import java.util.*;
public class GoodMatrix
{
    public static void main(String args[])
    throws Exception
    {
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        int[][] arr=new int[n][n];
        int sum=0;
                        int k=n-1;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                arr[i][j]=scan.nextInt();
            }
        }
        for(int i=0;i<n;i++)
        {
            if(i!=(n-1)/2)
            {
            sum=sum+arr[i][(n-1)/2];
        }
                if(i!=(n-1)/2)
                {
                sum=sum+arr[i][i];
            }
                if(i!=(n-1)/2)
                {
                sum=sum+arr[i][k];

            }
            k=k-1;
        }
                    for(int j=0;j<n;j++)
            {
                sum=sum+arr[(n-1)/2][j];
            }
        System.out.println(sum);
    }
}

import java.awt.geom.Point2D;
import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

    FastScanner in;
    PrintWriter out;

    public static final int MOD = 1000 * 1000 * 1000 + 7;
    public static final int INF = Integer.MAX_VALUE;

    /*  SOLUTION    */
    public void solve() {

        int n = in.nextInt();
        int[][]tab = new int[n][n];
        int sum = 0;

        for (int i = 0; i < tab.length; i++) {
            for (int j = 0; j < tab.length; j++) {
                tab[i][j] = in.nextInt();
            }
        }

        if (n == 1) {
            out.println(tab[0][0]);
            return;
        }
        if (n == 2) {
            sum += tab[0][0];
            sum += tab[0][tab.length - 1];
            sum += tab[tab.length - 1][0];
            sum += tab[tab.length - 1][tab.length - 1];
            out.println(sum);
            return;
        }
        if (n >= 3) {
            int s = (n - 1) / 2;
            for (int i = 0; i < tab.length/2; i++, s--) {
                for (int j = s; j < tab.length - s; j++) {
                    sum += tab[i][j];
                }
            }

//          for (int i = 0; i < tab.length; i++) {
//              sum += tab[(n - 1) / 2 + 1][i];
//          }
//          s++;
            for (int i = tab.length/2; i < tab.length; i++, s++) {
                for (int j = s; j < tab.length - s; j++) {
                    sum += tab[i][j];
                }
            }

            sum += tab[0][0];
            sum += tab[0][tab.length - 1];
            sum += tab[tab.length - 1][0];
            sum += tab[tab.length - 1][tab.length - 1];
            out.println(sum);
        }

    }

    Main() {
        in = new FastScanner(IO_Type.CONSOLE).getScanner();
        out = new FastWriter(IO_Type.CONSOLE).getWriter();
//       in = new FastScanner(IO_Type.FILE, "input.txt").getScanner();
//       out = new FastWriter(IO_Type.FILE, "output.txt").getWriter();
    }

    public static void main(String[] args) {
        Main task = new Main();
        task.solve();
        task.close();
    }

    public void close() {
        in.close();
        out.close();
    }
}

class Algebra {
    /****
     * Number of co-prime numbers on [1, n]. Number a is Co-prime if gcd (a, n)
     * == 1 O (sqrt(n))
     ****/
    public static int phi(int n) {
        int result = n;
        for (int i = 2; i * i <= n; ++i) {
            if (n % i == 0) {
                while (n % i == 0) {
                    n /= i;
                }
                result -= result / i;
            }
        }
        if (n > 1) {
            result -= result / n;
        }
        return result;
    }

    /****
     * Raise number a to power of n. O (log n)
     ****/
    public static int binpow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1)
                res *= a;
            a *= a;
            n >>= 1;
        }
        return res;
    }

    /****
     * Finding the greatest common divisor of two numbers. O (log min(a, b))
     ****/
    public static int gcd(int a, int b) {
        return (b != 0) ? gcd(b, a % b) : a;
    }

    /****
     * Finding the lowest common multiple of two numbers. O (log min(a, b))
     ****/
    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    /****
     * Eratosthenes Sieve of numbers - [0..n]. True - simple, False - not
     * simple. O (n log log n)
     ****/
    public static boolean[] sieveOfEratosthenes(int n) {
        boolean[] prime = new boolean[n + 1];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i <= n; ++i) {
            if (prime[i]) {
                if (i * 1L * i <= n) {
                    for (int j = i * i; j <= n; j += i) {
                        prime[j] = false;
                    }
                }
            }
        }
        return prime;
    }

    /****
     * Кодом Грея называется такая система нумерования неотрицательных чисел,
     * когда коды двух соседних чисел отличаются ровно в одном бите.
     * Например, для чисел длины 3 бита имеем такую последовательность кодов Грея: 000, 001, 011, 010, 110, 111, 101, 100.
     * Например, codeGray(4) = 6.
     ****/
    public static int codeGray (int n) {
        return n ^ (n >> 1);
    }

    /**
     * Даны два числа: n и k. Требуется посчитать, с какой степенью делитель k входит в число n!,
     *  т.е. найти наибольшее x такое, что делится на k^x.
     */
    public static int fact_pow (int n, int k) {
        int res = 0;
        while (n!=0) {
            n /= k;
            res += n;
        }
        return res;
    }

    /**
     * O(sqrt(N))
     * Факторизує число n
     * Вертає мапу з ключом - простим числом, і його значення, кількістю дільників.
     */
    public static TreeMap<Long, Integer> factorize(long n) {
        TreeMap<Long, Integer> factors = new TreeMap<Long, Integer>();
        for (long d = 2; n > 1;) {
            int cnt = 0;
            while (n % d == 0) {
                cnt++;
                n /= d;
            }
            if (cnt > 0) {
                factors.put(d, cnt);
            }
            d += (d == 2) ? 1 : 2;
            if (d * d > n) {
                d = n;
            }
        }
        return factors;
    }

    /**
     * O(sqrt(N))
     * Знаходження дільників числа n.
     */
    public static int[] getDivisors(int n) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 1; (long) i * i <= n; i++) {
            if (n % i == 0) {
                list.add(i);
                if (i * i != n) {
                    list.add(n / i);
                }
            }
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        Arrays.sort(res);
        return res;
    }
}

class Geometry {
    /**
     * Многоугольник без самопересечений называется решётчатым, если все его вершины находятся
     * в точках с целочисленными координатами (в декартовой системе координат).
     * Пусть дан некоторый решётчатый многоугольник, с ненулевой площадью.
     * Обозначим его площадь через S;
     * количество точек с целочисленными координатами, лежащих строго внутри многоугольника — через I;
     * количество точек с целочисленными координатами, лежащих на сторонах многоугольника — через B.
     */
    public static double Pika(int i, int b) {
        return i + b / 2 - 1;
    }

    static class PolygonAlgo {
        static final double eps = 1e-9;

        public static int sign(double a) {
            return Math.abs(a) < eps ? 0 : a < 0 ? -1 : 1;
        }

        public static double sqr(double x) {
            return x * x;
        }

        /**
         * Повертає значення гіпотенузи для заданих x,y.
         */
        public static double quickHypot(double x, double y) {
            return Math.sqrt(x * x + y * y);
        }

        public static class Point implements Comparable<Point> {
            double x, y;

            public Point(double x, double y) {
                this.x = x;
                this.y = y;
            }

            /**
             * Різниця двох точок
             * @return нова точка
             */
            public Point sub(Point b) {
                return new Point(x - b.x, y - b.y);
            }

            /**
             * Перетин двох точок
             * @return нова точка
             */
            public double cross(Point b) {
                return x * b.y - y * b.x;
            }

            public double dot(Point b) {
                return x * b.x + y * b.y;
            }

            /**
             * Сортування точок, спершу по x, у разі рівності x, сортування по y
             */
            public int compareTo(Point o) {
                int comp = sign(x - o.x);
                if (comp != 0)
                    return comp;
                return sign(y - o.y);
            }
        }

        public static class Line {
            double a, b, c;

            void norm() {
                double d = Math.sqrt(a * a + b * b);
                a /= d;
                b /= d;
                c /= d;
                if (a < -eps || a < eps && b < 0) {
                    a = -a;
                    b = -b;
                    c = -c;
                }
            }

            public Line(double a, double b, double c) {
                this.a = a;
                this.b = b;
                this.c = c;
                norm();
            }

            public Line(Point p1, Point p2) {
                a = +(p1.y - p2.y);
                b = -(p1.x - p2.x);
                c = p1.x * p2.y - p2.x * p1.y;
                norm();
            }

            public boolean parallel(Line line) {
                return sign(det(a, b, line.a, line.b)) == 0;
            }

            public boolean equivalent(Line line) {
                return sign(det(a, b, line.a, line.b)) == 0
                        && sign(det(a, c, line.a, line.c)) == 0
                        && sign(det(b, c, line.b, line.c)) == 0;
            }

            public double angle() {
                return Math.atan2(-a, b);
            }
        }

        public static double det(double a, double b, double c, double d) {
            return a * d - b * c;
        }

        public static double angle(Point a, Point p, Point b) {
            a = a.sub(p);
            b = b.sub(p);
            return Math.atan2(a.cross(b), a.dot(b));
        }

        public static double cross(Point a, Point b, Point c) {
            return b.sub(a).cross(c.sub(a));
        }

        public static int crossop(Point a, Point b, Point c) {
            return sign(cross(a, b, c));
        }

        public static boolean cw(Point a, Point b, Point c) {
            return crossop(a, b, c) < 0;
        }

        public static boolean ccw(Point a, Point b, Point c) {
            return crossop(a, b, c) > 0;
        }

        public static boolean isMiddle(double a, double m, double b) {
            return Math.abs(m - a) < eps || Math.abs(m - b) < eps
                    || (a < m) != (b < m);
        }

        public static boolean isMiddle(Point a, Point m, Point b) {
            return crossop(a, m, b) == 0 && isMiddle(a.x, m.x, b.x)
                    && isMiddle(a.y, m.y, b.y);
        }

        public static boolean isTouchIntersect(Point a, Point b, Point c,
                Point d) {
            return isMiddle(a, c, b) || isMiddle(a, d, b) || isMiddle(c, a, d)
                    || isMiddle(c, b, d);
        }

        public static boolean isCrossIntersect(Point a, Point b, Point c,
                Point d) {
            return crossop(a, b, c) * crossop(a, b, d) < 0
                    && crossop(c, d, a) * crossop(c, d, b) < 0;
        }

        public static boolean isIntersect(Point a, Point b, Point c, Point d) {
            return isCrossIntersect(a, b, c, d) || isTouchIntersect(a, b, c, d);
        }

        static boolean isIntersect2(double x1, double y1, double x2, double y2,
                double x3, double y3, double x4, double y4) {
            if (Math.max(x1, x2) < Math.min(x3, x4) - eps
                    || Math.max(x3, x4) < Math.min(x1, x2) - eps
                    || Math.max(y1, y2) < Math.min(y3, y4) - eps
                    || Math.max(y3, y4) < Math.min(y1, y2) - eps) {
                return false;
            }
            double z1 = (x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1);
            double z2 = (x4 - x1) * (y2 - y1) - (y4 - y1) * (x2 - x1);
            if (z1 < -eps && z2 < -eps || z1 > eps && z2 > eps) {
                return false;
            }
            double z3 = (x1 - x3) * (y4 - y3) - (y1 - y3) * (x4 - x3);
            double z4 = (x2 - x3) * (y4 - y3) - (y2 - y3) * (x4 - x3);
            if (z3 < -eps && z4 < -eps || z3 > eps && z4 > eps) {
                return false;
            }
            return true;
        }

        public static double signedArea(double[] x, double[] y) {
            int n = x.length;
            double s = 0;
            for (int i = 0; i < n; i++) {
                s += (x[(i + 1) % n] - x[i]) * (y[(i + 1) % n] + y[i]);
            }
            return s;
        }

        public static Point getIntersection(Point p1, Point p2, Point q1,
                Point q2) {
            return getIntersection(new Line(p1, p2), new Line(q1, q2));
        }

        public static Point getIntersection(Line A, Line B) {
            double a1 = A.a;
            double b1 = A.b;
            double c1 = A.c;
            double a2 = B.a;
            double b2 = B.b;
            double c2 = B.c;
            double det = a1 * b2 - a2 * b1;
            if (sign(det) == 0) {
                return null;
            }
            double x = -(c1 * b2 - c2 * b1) / det;
            double y = -(a1 * c2 - a2 * c1) / det;
            return new Point(x, y);
        }

        public static double pointToLineDistance(Point p, Line line) {
            return Math.abs(line.a * p.x + line.b * p.y + line.c)
                    / quickHypot(line.a, line.b);
        }

        public static double pointToSegmentDistance(Point p, Point a, Point b) {
            double dx = b.x - a.x;
            double dy = b.y - a.y;
            double px = p.x - a.x;
            double py = p.y - a.y;
            double squaredLength = dx * dx + dy * dy;
            double proj = dx * px + dy * py;
            if (proj < 0 || squaredLength < eps * eps) {
                return quickHypot(px, py);
            }
            if (proj > squaredLength) {
                return quickHypot(px - dx, py - dy);
            }
            return quickHypot(px - (double) proj / squaredLength * dx, py
                    - (double) proj / squaredLength * dy);
        }

        public static double pointToSegmentDistance2(Point p, Point a, Point b) {
            double s12 = sqr(a.x - b.x) + sqr(a.y - b.y);
            double s1 = sqr(p.x - a.x) + sqr(p.y - a.y);
            double s2 = sqr(p.x - b.x) + sqr(p.y - b.y);
            if (s12 > eps && Math.abs(s1 - s2) <= s12)
                return Math.abs(cross(p, a, b)) / Math.sqrt(s12);
            else
                return Math.sqrt(Math.min(s1, s2));
        }

        public static Point[] convexHull(Point[] p) {
            int n = p.length;
            if (n <= 1)
                return p;
            int k = 0;
            Arrays.sort(p);
            Point[] q = new Point[n * 2];
            for (int i = 0; i < n; q[k++] = p[i++])
                for (; k > 1 && !cw(q[k - 2], q[k - 1], p[i]); --k)
                    ;
            for (int i = n - 2, t = k; i >= 0; q[k++] = p[i--])
                for (; k > t && !cw(q[k - 2], q[k - 1], p[i]); --k)
                    ;
            Point[] res = new Point[k - 1 - (q[0].compareTo(q[1]) == 0 ? 1 : 0)];
            System.arraycopy(q, 0, res, 0, res.length);
            return res;
        }

        Point[] convexCut(Point[] poly, Point p1, Point p2) {
            int n = poly.length;
            ArrayList<Point> res = new ArrayList<Point>();
            for (int i = 0, j = n - 1; i < n; j = i++) {
                int d1 = sign(p2.sub(p1).cross(poly[i].sub(p1)));
                int d2 = sign(p2.sub(p1).cross(poly[j].sub(p1)));
                if (d1 >= 0)
                    res.add(poly[i]);
                if (d1 * d2 < 0)
                    res.add(getIntersection(p1, p2, poly[i], poly[j]));
            }
            return res.toArray(new Point[0]);
        }

        public static enum Location {
            BOUNDARY, INTERIOR, EXTERIOR;
        }

        public static Location pointInPolygon(Point p0, Point[] poly) {
            int n = poly.length;
            Point[] p = new Point[n];
            for (int i = 0; i < p.length; i++)
                p[i] = poly[i].sub(p0);
            int cnt = 0;
            for (int i = 0, j = n - 1; i < n; j = i++) {
                if (sign(p[i].y) == 0
                        && (sign(p[i].x) == 0 || sign(p[j].y) == 0
                                && (sign(p[i].x) < 0) != (sign(p[j].x) < 0)))
                    return Location.BOUNDARY;

                if (sign(p[i].y) > 0 != sign(p[j].y) > 0) {
                    double det = p[i].cross(p[j]);
                    if (sign(det) == 0)
                        return Location.BOUNDARY;
                    if (sign(det) > 0 != sign(p[j].y - p[i].y) > 0)
                        ++cnt;
                }
            }
            return cnt % 2 == 0 ? Location.EXTERIOR : Location.INTERIOR;
        }

        public static enum Position {
            LEFT, RIGHT, BEHIND, BEYOND, ORIGIN, DESTINATION, BETWEEN;
        }

        public static Position classify(Point a, Point b, Point p) {
            int s = crossop(a, b, p);
            if (s > eps) {
                return Position.LEFT;
            }
            if (s < -eps) {
                return Position.RIGHT;
            }
            if (sign(p.x - a.x) == 0 && sign(p.y - a.y) == 0) {
                return Position.ORIGIN;
            }
            if (sign(p.x - b.x) == 0 && sign(p.y - b.y) == 0) {
                return Position.DESTINATION;
            }
            // if (ax * bx < 0 || ay * by < 0) {
            if (isMiddle(a, b, p)) {
                return Position.BEYOND;
            }
            // if (ax * ax + ay * ay < bx * bx + by * by) {
            if (isMiddle(b, a, p)) {
                return Position.BEHIND;
            }
            return Position.BETWEEN;
        }
    }

    static class CircleAlgo {
        static final double eps = 1e-9;

        public static double sqr(double x) {
            return x * x;
        }

        public static double quickHypot(double x, double y) {
            return Math.sqrt(x * x + y * y);
        }

        public static class Point {
            double x, y;

            public Point(double x, double y) {
                this.x = x;
                this.y = y;
            }
        }

        public static class Circle {
            double r, x, y;

            public Circle(double x, double y, double r) {
                this.x = x;
                this.y = y;
                this.r = r;
            }

            public boolean contains(Point p) {
                return quickHypot(p.x - x, p.y - y) < r + eps;
            }
        }

        public static Circle getCircumCircle(Point a, Point b) {
            double x = (a.x + b.x) / 2.;
            double y = (a.y + b.y) / 2.;
            double r = quickHypot(a.x - x, a.y - y);
            return new Circle(x, y, r);
        }

        public static Circle getCircumCircle(Point a, Point b, Point c) {
            double Bx = b.x - a.x;
            double By = b.y - a.y;
            double Cx = c.x - a.x;
            double Cy = c.y - a.y;
            double d = 2 * (Bx * Cy - By * Cx);
            double z1 = Bx * Bx + By * By;
            double z2 = Cx * Cx + Cy * Cy;
            double cx = Cy * z1 - By * z2;
            double cy = Bx * z2 - Cx * z1;
            double x = (double) cx / d;
            double y = (double) cy / d;
            double r = quickHypot(x, y);
            return new Circle(x + a.x, y + a.y, r);
        }

        public static class Line {
            double a, b, c;

            public Line(double a, double b, double c) {
                this.a = a;
                this.b = b;
                this.c = c;
            }

            public Line(Point p1, Point p2) {
                a = +(p1.y - p2.y);
                b = -(p1.x - p2.x);
                c = p1.x * p2.y - p2.x * p1.y;
            }
        }

        // geometric solution
        public static List<Point2D.Double> circleLineIntersection(
                Circle circle, Line line) {
            double a = line.a;
            double b = line.b;
            double c = line.c + circle.x * a + circle.y * b;
            double r = circle.r;
            double aabb = a * a + b * b;
            List<Point2D.Double> res = new ArrayList<Point2D.Double>();
            double d = c * c / aabb - r * r;
            if (d > eps)
                return res;
            double x0 = -a * c / aabb;
            double y0 = -b * c / aabb;
            if (d > -eps) {
                res.add(new Point2D.Double(x0 + circle.x, y0 + circle.y));
                return res;
            }
            d /= -aabb;
            double k = Math.sqrt(d < 0 ? 0 : d);
            res.add(new Point2D.Double(x0 + k * b + circle.x, y0 - k * a
                    + circle.y));
            res.add(new Point2D.Double(x0 - k * b + circle.x, y0 + k * a
                    + circle.y));
            return res;
        }

        // algebraic solution
        public static List<Point2D.Double> circleLineIntersection2(
                Circle circle, Line line) {
            double a = line.a;
            double b = line.b;
            double c = line.c;
            double CX = circle.x, CY = circle.y;
            double R = circle.r;
            // ax+by+c=0
            // (by+c+aCX)^2+(ay-aCY)^2=(aR)^2
            boolean swap = false;
            if (Math.abs(a) < Math.abs(b)) {
                swap = true;
                double t = a;
                a = b;
                b = t;
                t = CX;
                CX = CY;
                CY = t;
            }
            List<Point2D.Double> res = new ArrayList<Point2D.Double>();
            double A = a * a + b * b;
            double B = 2.0 * b * (c + a * CX) - 2.0 * a * a * CY;
            double C = sqr(c + a * CX) + a * a * (CY * CY - R * R);
            double d = B * B - 4 * A * C;
            if (d < -eps)
                return res;
            d = Math.sqrt(d < 0 ? 0 : d);
            double y1 = (-B + d) / (2 * A);
            double x1 = (-c - b * y1) / a;
            double y2 = (-B - d) / (2 * A);
            double x2 = (-c - b * y2) / a;
            if (swap) {
                double t = x1;
                x1 = y1;
                y1 = t;
                t = x2;
                x2 = y2;
                y2 = t;
            }
            res.add(new Point2D.Double(x1, y1));
            if (d > eps)
                res.add(new Point2D.Double(x2, y2));
            return res;
        }

        public static List<Point2D.Double> circleCircleIntersection(Circle c1,
                Circle c2) {
            if (quickHypot(c1.x - c2.x, c1.y - c2.y) < eps) {
                if (Math.abs(c1.r - c2.r) < eps) {
                    // infinity intersection points
                    return null;
                }
                return new ArrayList<Point2D.Double>();
            }
            c2.x -= c1.x;
            c2.y -= c1.y;
            double A = -2 * c2.x;
            double B = -2 * c2.y;
            double C = c2.x * c2.x + c2.y * c2.y + c1.r * c1.r - c2.r * c2.r;
            List<Point2D.Double> res = circleLineIntersection(new Circle(0, 0,
                    c1.r), new Line(A, B, C));
            for (Point2D.Double point : res) {
                point.x += c1.x;
                point.y += c1.y;
            }
            return res;
        }

        public static double circleCircleIntersectionArea(Circle c1, Circle c2) {
            double r = Math.min(c1.r, c2.r);
            double R = Math.max(c1.r, c2.r);
            double d = quickHypot(c1.x - c2.x, c1.y - c2.y);
            if (d < R - r + eps) {
                return Math.PI * r * r;
            }
            if (d > R + r - eps) {
                return 0;
            }
            double area = r
                    * r
                    * Math.acos((d * d + r * r - R * R) / 2 / d / r)
                    + R
                    * R
                    * Math.acos((d * d + R * R - r * r) / 2 / d / R)
                    - 0.5
                    * Math.sqrt((-d + r + R) * (d + r - R) * (d - r + R)
                            * (d + r + R));
            return area;
        }

        static Circle minEnclosingCircleWith2Points(List<Point> points,
                Point q1, Point q2) {
            Circle circle = getCircumCircle(q1, q2);
            for (int i = 0; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = getCircumCircle(q1, q2, points.get(i));
                }
            }
            return circle;
        }

        static Circle minEnclosingCircleWith1Point(List<Point> pointsList,
                Point q) {
            List<Point> points = new ArrayList<Point>(pointsList);
            Collections.shuffle(points);
            Circle circle = getCircumCircle(points.get(0), q);
            for (int i = 1; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = minEnclosingCircleWith2Points(
                            points.subList(0, i), points.get(i), q);
                }
            }
            return circle;
        }

        public static Circle minEnclosingCircle(Point[] pointsArray) {
            if (pointsArray.length == 0) {
                return new Circle(0, 0, 0);
            }
            if (pointsArray.length == 1) {
                return new Circle(pointsArray[0].x, pointsArray[0].y, 0);
            }
            List<Point> points = Arrays.asList(pointsArray);
            Collections.shuffle(points);
            Circle circle = getCircumCircle(points.get(0), points.get(1));
            for (int i = 2; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = minEnclosingCircleWith1Point(points.subList(0, i),
                            points.get(i));
                }
            }
            return circle;
        }
    }

}

class Graph {
    private static final int INF = Integer.MAX_VALUE;

    /****
     * g - graph as list sumiznosti s - number of vertix from bfs started n -
     * number of all vertixes p - array with indexes of all parent vertix for
     * each other d - array with distance from start vertix to each other [if g
     * - zvazhenii, d[to] = d[v] + weigth of edge]
     *
     * В результате поиска в ширину находится путь кратчайшей длины в
     * невзвешененном графе, т.е. путь, содержащий наименьшее число рёбер.
     * Алгоритм работает за , где — число вершин, — число рёбер.
     *
     * if (!used[to]) System.out.println("No path!"); else { ArrayList <Integer>
     * path = new ArrayList<Integer>(); for (int v = to; v != -1; v = p[v]) {
     * path.add(v); } reverse (path.begin(), path.end());
     * System.out.println("Path:") for (int i = 0; i < path.size(); ++i) {
     * System.out.println(path[i] + 1); } }
     ****/
    public static void bfs(int s, ArrayList<Integer>[] g) {
        int n = g.length;
        Queue<Integer> q = new LinkedList<Integer>();
        q.add(s);
        boolean[] used = new boolean[n];
        int[] d = new int[n];
        int[] p = new int[n];
        used[s] = true;
        p[s] = -1;
        while (!q.isEmpty()) {
            int v = q.poll();
            for (int i = 0; i < g[v].size(); ++i) {
                int to = g[v].get(i);
                if (!used[to]) {
                    used[to] = true;
                    q.add(to);
                    d[to] = d[v] + 1;
                    p[to] = v;
                }
            }
        }
    }

    /****
     * g - graph as list sumiznosti v - number of vertix from dfs calls n -
     * number of all vertixes used - array which shows be or not visited vertix
     *
     * В результате поиска в глубину находится лексикографически первый путь в
     * графе. Алгоритм работает за O (N+M).
     *
     *
     ****/
    static int n = 100500;  // вершин
    static int m = 100500;  // ребер
    static ArrayList<Integer>[] g = new ArrayList[n];
    static boolean[] used = new boolean[g.length];

    public static void dfs(int v) {
        used[v] = true;
        for (int i = 0; i < g[v].size(); i++) {
            int to = g[v].get(i);
            if (!used[to]) {
                dfs(to);
            }
        }
    }

    /****
     * g - graph as list sumiznosti n - number of all vertixes used - array
     * which shows be or not visited vertix
     *
     * ans - список із відсорченими вершинами
     *
     * Дан ориентированный граф с вершинами и рёбрами. Требуется перенумеровать
     * его вершины таким образом, чтобы каждое рёбро вело из вершины с меньшим
     * номером в вершину с большим. Иными словами, требуется найти перестановку
     * вершин (топологический порядок), соответствующую порядку, задаваемому
     * всеми рёбрами графа.
     *
     ****/
    static ArrayList<Integer> ans = new ArrayList<Integer>();

    public static void topologicalSort() {
        for (int i = 0; i < n; ++i)
            used[i] = false;
        ans.clear();
        for (int i = 0; i < n; ++i)
            if (!used[i])
                dfs(i);
        Collections.reverse(ans);
    }

    class Pair {
        int first;
        int second;
        public Pair(int to, int len) {
            first = to;
            second = len;
        }
    }

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

    /**
     * O(n^2 + m)
     * Дан ориентированный или неориентированный взвешенный граф с n вершинами и m рёбрами.
     * Веса всех рёбер неотрицательны. Указана некоторая стартовая вершина s.
     * Требуется найти длины кратчайших путей из вершины s во все остальные вершины,
     * а также предоставить способ вывода самих кратчайших путей.
     *
     * После выполнения всех итераций в массиве d[] оказываются длины кратчайших путей до всех вершин,
     * а в массиве p[] — предки всех вершин (кроме стартовой s). Восстановить путь до любой вершины t можно следующим образом:
     *
     * vector<int> path;
     * for (int v=t; v!=s; v=p[v])
     *  path.push_back (v);
     *  path.push_back (s);
     *  reverse (path.begin(), path.end());
     */
    public static void Dejkstra(int s, ArrayList<Pair>[] g) {
        int[]d = new int[n];
        int[]p = new int[n];
        Arrays.fill(d, INF);
        d[s] = 0;
        boolean[]u = new boolean[n];
        for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                if (!u[j] && (v == -1 || d[j] < d[v]))
                    v = j;
            if (d[v] == INF)
                break;
            u[v] = true;

            for (int j=0; j<g[v].size(); ++j) {
                int to = g[v].get(j).first,
                    len = g[v].get(j).second;
                if (d[v] + len < d[to]) {
                    d[to] = d[v] + len;
                    p[to] = v;
                }
            }
        }
    }

    /**
     * O(N*M)
     * Пусть дан ориентированный взвешенный граф G с n вершинами и m рёбрами,
     * и указана некоторая вершина v. Требуется найти длины кратчайших путей от вершины v до всех остальных вершин.
     *
     * В отличие от алгоритма Дейкстры, этот алгоритм применим также и к графам, содержащим рёбра отрицательного веса.
     * Впрочем, если граф содержит отрицательный цикл, то, понятно, кратчайшего пути до некоторых вершин может
     * не существовать (по причине того, что вес кратчайшего пути должен быть равен минус бесконечности);
     * впрочем, этот алгоритм можно модифицировать, чтобы он сигнализировал о наличии цикла отрицательного веса,
     * или даже выводил сам этот цикл.
     *
     * Заведём массив расстояний d[], который после отработки алгоритма будет содержать ответ на задачу.
     *
     * if (d[t] == INF)
     *      cout << "No path from " << v << " to " << t << ".";
     *  else {
     *      vector<int> path;
     *      for (int cur=t; cur!=-1; cur=p[cur])
     *          path.push_back (cur);
     *      reverse (path.begin(), path.end());
     *      cout << "Path from " << v << " to " << t << ": ";
     *      for (size_t i=0; i<path.size(); ++i)
     *          cout << path[i] << ' ';
     * }
     */
    public static void FordBellman(int v, ArrayList <Edge> e) {
        int[]d = new int[n];
        int[]p = new int[n];

        Arrays.fill(d, INF);
        Arrays.fill(p, -1);

        d[v] = 0;
        for (;;) {
            boolean any = false;
            for (int j=0; j<m; ++j)
                if (d[e.get(j).a] < INF)
                    if (d[e.get(j).b] > d[e.get(j).a] + e.get(j).cost) {
                        d[e.get(j).b] = d[e.get(j).a] + e.get(j).cost;
                        p[e.get(j).b] = e.get(j).a;

                        any = true;
                    }
            if (!any)  break;
        }
    }

    /**
     * O(N^3)
     * Дан ориентированный или неориентированный взвешенный граф G с n вершинами.
     * Требуется найти значения всех величин dij — длины кратчайшего пути из вершины i в вершину j.
     *
     * На вход программе подаётся граф, заданный в виде матрицы смежности — двумерного массива d[][] размера n*n,
     * в котором каждый элемент задаёт длину ребра между соответствующими вершинами.
     * Требуется, чтобы выполнялось d[i][i] = 0 для любых i.
     */
    public static void FloydWorshall(int[][]d) {
        for (int k=0; k<n; ++k)
            for (int i=0; i<n; ++i)
                for (int j=0; j<n; ++j)
                    if (d[i][k] < INF && d[k][j] < INF)
                        d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
    }

    /**
     * O(n^2)
     *
     * Дан взвешенный неориентированный граф G с n вершинами и m рёбрами.
     * Требуется найти такое поддерево этого графа, которое бы соединяло все его вершины,
     * и при этом обладало наименьшим возможным весом (т.е. суммой весов рёбер).
     * Поддерево — это набор рёбер, соединяющих все вершины, причём из любой вершины можно
     * добраться до любой другой ровно одним простым путём.
     *
     * Такое поддерево называется минимальным остовным деревом или просто минимальным остовом.
     * Легко понять, что любой остов обязательно будет содержать n - 1 ребро.
     * В естественной постановке эта задача звучит следующим образом: есть n городов, и для каждой
     * пары известна стоимость соединения их дорогой (либо известно, что соединить их нельзя).
     * Требуется соединить все города так, чтобы можно было доехать из любого города в другой,
     * а при этом стоимость прокладки дорог была бы минимальной.
     *
     *
     * На вход подаются число вершин n и матрица g[][] размера n*n,
     * в которой отмечены веса рёбер, и стоят числа INF, если соответствующее ребро отсутствует.
     * Алгоритм поддерживает три массива: флаг used[i] = true означает, что вершина i включена в остов,
     * величина min_e[i] хранит вес наименьшего допустимого ребра из вершины i,
     * а элемент sel_e[i] содержит конец этого наименьшего ребра (это нужно для вывода рёбер в ответе).
     * Алгоритм делает n шагов, на каждом из которых выбирает вершину v с наименьшей меткой min_e, помечает её used,
     * и затем просматривает все рёбра из этой вершины, пересчитывая их метки.   *
     */
    public static void Prima(int g[][]) {
        boolean[]used = new boolean[n];
        int[]min_e = new int[n];
        int[]sel_e = new int[n];
        Arrays.fill(min_e, INF);
        Arrays.fill(sel_e, -1);

        min_e[0] = 0;
        for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                if (!used[j] && (v == -1 || min_e[j] < min_e[v]))
                    v = j;
            if (min_e[v] == INF) {
                System.out.println("No MST!");
                return;
            }

            used[v] = true;
            if (sel_e[v] != -1)
                System.out.println(v + " " + sel_e[v]);

            for (int to=0; to<n; ++to)
                if (g[v][to] < min_e[to]) {
                    min_e[to] = g[v][to];
                    sel_e[to] = v;
                }
        }
    }

    static int[]cl;
    static int[]p;
    static int cycle_st;
    static int cycle_end;

    /**
     * O(M)
     * Пусть дан ориентированный или неориентированный граф без петель и кратных рёбер.
     * Требуется проверить, является ли он ациклическим, а если не является, то найти любой цикл.
     */

    public static void FindCircle(ArrayList<Integer>[] g) {
        p = new int[n];
        Arrays.fill(p, -1);
        cl = new int[n];
        cycle_st = -1;
        for (int i=0; i<n; ++i)
            if (dfsForCircle(i, g))
                break;

        if (cycle_st == -1)
            System.out.println("Acyclic");
        else {
            System.out.println("Cyclic");
            ArrayList<Integer>cycle = new ArrayList<Integer>();;
            cycle.add(cycle_st);
            for (int v=cycle_end; v!=cycle_st; v=p[v])
                cycle.add(v);
            cycle.add(cycle_st);
            Collections.reverse(cycle);
            for (int i=0; i<cycle.size(); ++i)
                System.out.println(cycle.get(i)+1);
        }
    }

    public static boolean dfsForCircle (int v, ArrayList<Integer>[] g) {
        cl[v] = 1;
        for (int i=0; i<g[v].size(); ++i) {
            int to = g[v].get(i);
            if (cl[to] == 0) {
                p[to] = v;
                if (dfsForCircle (to, g))  return true;
            }
            else if (cl[to] == 1) {
                cycle_end = v;
                cycle_st = to;
                return true;
            }
        }
        cl[v] = 2;
        return false;
    }
}

class StringUtil {

    /**
     * Пусть дана строка s длины n. Тогда Z-функция от этой строки — это массив длины n, i-ый элемент
     * которого равен наибольшему числу символов, начиная с позиции i, совпадающих с первыми символами строки s.
     * Иными словами, z[i] — это наибольший общий префикс строки s и её i-го суффикса.
     *
     * Example:
     * "aaabaab"
     * z[0] = 0
     * z[1] = 2
     * z[2] = 1
     * z[3] = 0
     * z[4] = 2
     * z[5] = 1
     * z[6] = 0
     */
    public static int[] zFunction (String s) {
        int n = s.length();
        int[]z = new int[n];
        for (int i=1, l=0, r=0; i<n; ++i) {
            if (i <= r)
                z[i] = Math.min(r-i+1, z[i-l]);
            while (i+z[i] < n && s.charAt(z[i]) == s.charAt(i+z[i]))
                ++z[i];
            if (i+z[i]-1 > r) {
                l = i;
                r = i+z[i]-1;
            }
        }
        return z;
    }

    public static int[] prefixFunction(String s) {
        int n = s.length();
        int[] p = new int[n];
        for (int i = 1; i < n; i++) {
            int k = p[i - 1];
            while (k > 0 && s.charAt(k) != s.charAt(i)) {
                k = p[k - 1];
            }
            p[i] = k + (s.charAt(k) == s.charAt(i) ? 1 : 0);
        }
        return p;
    }

    /**
     * s - текст в якому шукаєм
     * pattern - слово яке шукаємо
     * Повертає -1 якщо немає входження, або індекс входження
     */
    public static int kmpMatcher(String s, String pattern) {
        int m = pattern.length();
        if (m == 0) {
            return 0;
        }
        int n = s.length();
        int[] p = prefixFunction(pattern);
        int k = 0;
        for (int i = 0; i < n; i++) {
            while (k > 0 && s.charAt(i) != pattern.charAt(k)) {
                k = p[k - 1];
            }
            if (s.charAt(i) == pattern.charAt(k)) {
                k++;
            }
            if (k == m) {
                return i - m + 1;
            }
        }
        return -1;
    }

    /**
     * Дана строка S и текст T, состоящие из маленьких латинских букв.
     * Требуется найти все вхождения строки S в текст T за время O (|S| + |T|).
     * Алгоритм. Посчитаем хэш для строки S. Посчитаем значения хэшей для всех префиксов строки T.
     * Теперь переберём все подстроки T длины |S| и каждую сравним с |S| за время O (1).
     */
    public static ArrayList<Integer> RabinKarp(String s, String t) {
        ArrayList<Integer>indexes = new ArrayList<Integer>();
        final int p = 31;
        long[]p_pow = new long[Math.max(s.length(), t.length())];
        p_pow[0] = 1;
        for (int i=1; i<p_pow.length; ++i)
            p_pow[i] = p_pow[i-1] * p;

        long[]h = new long[(t.length())];
        for (int i=0; i<t.length(); ++i)
        {
            h[i] = (t.charAt(i) - 'a' + 1) * p_pow[i];
            if (i!=0)  h[i] += h[i-1];
        }

        long h_s = 0;
        for (int i=0; i<s.length(); ++i)
            h_s += (s.charAt(i) - 'a' + 1) * p_pow[i];

        for (int i = 0; i + s.length() - 1 < t.length(); ++i)
        {
            long cur_h = h[i+s.length()-1];
            if (i!=0)  cur_h -= h[i-1];
            if (cur_h == h_s * p_pow[i])
                indexes.add(i);
        }
        return indexes;
    }

    public static void palindromsCount(String s) {
        int n = s.length();
        int[]d1 = new int[n];
        int l=0, r=-1;
        for (int i=0; i<n; ++i) {
            int k = (i>r ? 0 : Math.min (d1[l+r-i], r-i)) + 1;
            while (i+k < n && i-k >= 0 && s.charAt(i+k) == s.charAt(i-k))  ++k;
            d1[i] = k--;
            if (i+k > r) {
                l = i-k;
                r = i+k;
            }
        }

        int[]d2 = new int[n];
        l=0;
        r=-1;
        for (int i=0; i<n; ++i) {
            int k = (i>r ? 0 : Math.min (d2[l+r-i+1], r-i+1)) + 1;
            while (i+k-1 < n && i-k >= 0 && s.charAt(i+k-1) == s.charAt(i-k))  ++k;
            d2[i] = --k;
            if (i+k-1 > r) {
                l = i-k;
                r = i+k-1;
            }
        }
    }
}

class Combinatorica {
    /**
     * Перестановка з n - елементів
     * P = n!
     */
    public static long P(int n) {
        long ans = 1;
        if (n == 0) return 0;
        while (n > 0) {
            ans *= n;
            n--;
        }
        return ans;
    }

    /**
     * Кількість можливих m - елементних множин з множини з n елементів.
     * С(m, n) = n! / (m! * (n - m)!)   m <= n
     */
    public static long C(int m, int n) {
        if (m == 0 || m == n) return 1;
        long a = Combinatorica.P(n);
        long b = Combinatorica.P(m);
        long c = Combinatorica.P(n - m);
        return a / b / c;
    }

    /**
     * Кількість різних комбінацій із n елементів по m елементів з повтореннями становить
     * C(n - 1, n + m - 1) = C(m, n + m - 1)
     */
    public static long CwithRepeat(int n, int m) {
        return C(n - 1, n + m - 1);
    }

    /**
     * Кількість упорядкованих m-елементних підмножин n-елементної множини, всі m елементів якої різні
     */
    public static long A(int m, int n) {
        return Combinatorica.P(n) / Combinatorica.P(n - m);
    }
 }

class Matrix {
    /**
     * Додати дві матриці
     * @param a - матриця1
     * @param b - матриця2
     * @return нова матриця (а + б)
     */
    public static long[][] matrixAdd(long[][] a, long[][] b) {
        int n = a.length;
        int m = a[0].length;
        long[][] res = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                res[i][j] = a[i][j] + b[i][j];
            }
        }
        return res;
    }

    /**
     * Множення двох матриць
     * @param a - матриця1
     * @param b - матриця2
     * @return нова матриця (а * б)
     */
    public static long[][] matrixMul(long[][] a, long[][] b) {
        int n = a.length;
        int m = a[0].length;
        int k = b[0].length;
        long[][] res = new long[n][k];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < k; j++) {
                for (int p = 0; p < m; p++) {
                    res[i][j] = res[i][j] + a[i][p] * b[p][j];
                }
            }
        }
        return res;
    }

    /**
     * Піднести матрицю до степеня P
     * @param a - матриця
     * @param P - степінь
     * @return нова матриця a^P
     */
    public static long[][] matrixPow(long[][] a, long p) {
        if (p == 0) {
            return matrixUnit(a.length);
        } else if (p % 2 == 0) {
            return matrixPow(matrixMul(a, a), p / 2);
        } else {
            return matrixMul(a, matrixPow(a, p - 1));
        }
    }

    public static long[][] matrixPowSum(long[][] a, long p) {
        int n = a.length;
        if (p == 0) {
            return new long[n][n];
        }
        if (p % 2 == 0) {
            return matrixMul(matrixPowSum(a, p / 2),
                    matrixAdd(matrixUnit(n), matrixPow(a, p / 2)));
        } else {
            return matrixAdd(a, matrixMul(matrixPowSum(a, p - 1), a));
        }
    }

    /**
     * Cтворення одиничної матриці розміром n*n
     * @param n
     * @return матриця заповнена одиницями.
     */
    public static long[][] matrixUnit(int n) {
        long[][] res = new long[n][n];
        for (int i = 0; i < n; ++i) {
            res[i][i] = 1;
        }
        return res;
    }
}

class IO_Type {

    public static String CONSOLE = "console";
    public static String FILE = "file";

}

class BigIntegerUtil {
    public static BigInteger pow(BigInteger a, int exponent) {
        return a.pow(exponent);
    }
    public static BigInteger subtract(BigInteger a, BigInteger b) {
        return a.subtract(b);
    }
    public static BigInteger add(BigInteger a, BigInteger b) {
        return a.add(b);
    }
    public static BigInteger multiply(BigInteger a, BigInteger b) {
        return a.multiply(b);
    }
    public static BigInteger divide(BigInteger a, BigInteger b) {
        return a.divide(b);
    }
}

class FastScanner {

    BufferedReader br;
    StringTokenizer st;

    FastScanner getScanner() {
        return this;
    }

    FastScanner(String type) {
        if (type.equals("console")) {
            FastScanner(System.in);
        }
    }

    FastScanner(String type, String inFileName) {
        if (type.equals("file")) {
            File f = new File(inFileName);
            try {
                FastScanner(new FileInputStream(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    void FastScanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
    }

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                System.err.println(e);
                return "";
            }
        }
        return st.nextToken();
    }

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

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

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

    float nextFloat() {
        return Float.parseFloat(next());
    }

    BigInteger nextBigInt() {
        return new BigInteger(next());
    }

    void close() {
        try {
            br.close();
        } catch (IOException e) {
        }
    }
}

class FastWriter {

    PrintWriter pw;

    PrintWriter getWriter() {
        return pw;
    }

    FastWriter(String type) {
        FastWriter(type);
    }

    FastWriter(String type, String outFileName) {
        FastWriter(type, outFileName);
    }

    PrintWriter FastWriter(String type) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        return pw;
    }

    PrintWriter FastWriter(String type, String outFileName) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        else if (type.equals("file")) {
            try {
                pw = new PrintWriter(new File(outFileName));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        return pw;
    }
}

/***
*   Help:
*   https://sites.google.com/site/indy256/algo/
*   http://e-maxx.ru/algo/
*/

import java.util.*;
public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input=new Scanner(System.in);
		while(input.hasNext()){
			int sum=0;
			int size=input.nextInt();
			Vertex [][]array=new Vertex [size][size];
			for(int i=0;i<size;i++){
				for(int j=0;j<size;j++){
					array[i][j]=new Vertex(input.nextInt());
					if(i==j){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
					if(i+j==size-1&&!array[i][j].judge){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
					if(i==(size-1)/2&&!array[i][j].judge){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
					if(j==(size-1)/2&&!array[i][j].judge){
						sum+=array[i][j].value;
						array[i][j].judge=true;
					}
				}
			}
			System.out.println(sum);
		}
	}

}
class Vertex{
	boolean judge=false;
	int value;
	Vertex(int value){
		this.value=value;
	}
}

import java.awt.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
	private static BufferedReader br;
	private static StringTokenizer st;
	private static PrintWriter pw;

	public static void main(String[] args) throws IOException	{
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int n = readInt();
		int[][] grid = new int[n][n];
		loadArray(grid);
		int ret = 0;
		for(int i = 0; i < n; i++)	{
			for(int j = 0; j < n; j++)	{
				boolean a = i == j;
				boolean b = i+j == n-1;
				boolean c = i == n/2;
				boolean d = j == n/2;
				if(a||b||c||d)
					ret += grid[i][j];
			}
		}
		pw.println(ret);
		pw.close();
	}

	/* NOTEBOOK CODE */

	public static void loadArray(int[][] grid) throws IOException {
		for(int[] a: grid)
			loadArray(a);
	}

	public static void loadArray(int[] in) throws IOException {
		for(int i = 0; i < in.length; i++)
			in[i] = readInt();
	}

	public static void loadArray(long[] in) throws IOException {
		for(int i = 0; i < in.length; i++)
			in[i] = readLong();
	}

	private static long readLong() throws IOException	{
		return Long.parseLong(nextToken());
	}

	private static double readDouble() throws IOException	{
		return Double.parseDouble(nextToken());
	}

	private static int readInt() throws IOException	{
		return Integer.parseInt(nextToken());
	}

	private static String nextToken() throws IOException	{
		while(st == null || !st.hasMoreTokens())	{
			if(!br.ready())	{
				pw.close();
				System.exit(0);
			}
			st = new StringTokenizer(br.readLine().trim());
		}
		return st.nextToken();
	}
}

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

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

  static class TaskA1 {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
      int n = in.nextInt();

      int[][] grid = new int[n][n];

      for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
          grid[i][j] = in.nextInt();
        }
      }

      int answer = 0;

      int half = n / 2;
      for (int i = 0; i < n; i++) {
        if (i == half) {
          answer += grid[half][half];
        } else {
          answer += grid[half][i] + grid[i][half] + grid[i][i] + grid[i][n - i - 1];
        }
      }

      out.print(answer);
    }
  }
}

import java.util.Scanner;

public class Main {
	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int[][] f = new int[n][n];
		boolean[][] b = new boolean[n][n];
		for (int i=0;i<n;i++) {
			for (int j=0;j<n;j++) {
				f[i][j] = in.nextInt();
				if (i==j) {
					b[i][j] = true;
				}
				if ((j+i)==(n-1)) {
					b[i][j] = true;
				}
				if (i==((n-1)/2)) {
					b[i][j] = true;
				}
				if (j==((n-1)/2)) {
					b[i][j] = true;
				}
			}
		}

		long res = 0;
		for (int i=0;i<n;i++) {
			for (int j=0;j<n;j++) {
				if (b[i][j]) {
					res+=f[i][j];
				}
			}
		}

		System.out.println(res);
	}
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Домашний
 */
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class A {

        final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
        BufferedReader in;
        PrintWriter out;
        StringTokenizer tok = new StringTokenizer("");

        void init() throws FileNotFoundException{
                if (ONLINE_JUDGE){
                        in = new BufferedReader(new InputStreamReader(System.in));
                        out = new PrintWriter(System.out);
                }else{
                        in = new BufferedReader(new FileReader("input.txt"));
                        out = new PrintWriter("output.txt");
                }
        }

        String readString() throws IOException{
                while(!tok.hasMoreTokens()){
                        tok = new StringTokenizer(in.readLine());
                }
                return tok.nextToken();
        }

        int readInt() throws IOException{
                return Integer.parseInt(readString());
        }

        long readLong() throws IOException{
                return Long.parseLong(readString());
        }

        double readDouble() throws IOException{
                return Double.parseDouble(readString());
        }

        int[] readArr(int n) throws IOException{
        	int[] res = new int[n];
        	for(int i = 0; i < n; i++){
        		res[i] = readInt();
        	}
        	return res;
        }

        long[] readArrL(int n) throws IOException{
        	long[] res = new long[n];
        	for(int i = 0; i < n; i++){
        		res[i] = readLong();
        	}
        	return res;
        }

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

        public void run(){
                try{
                        long t1 = System.currentTimeMillis();
                        init();
                        solve();
                        out.close();
                        long t2 = System.currentTimeMillis();
                        System.err.println("Time = "+(t2-t1));
                }catch (Exception e){
                        e.printStackTrace(System.err);
                        System.exit(-1);
                }
        }

        void solve() throws IOException{
            int n = readInt();
            int[][] a = new int[n][n];
            for(int i=0;i < n; i++){
                for(int j = 0; j <n; j++){
                    a[i][j] = readInt();
                }
            }
            int summ = 0;
            for(int i = 0; i < n; i++){
                for(int j = 0; j < n; j++){
                    if(i == j){
                        summ += a[i][j];
                        continue;
                    }
                    if(i == n-1-j){
                        summ += a[i][j];
                        continue;
                    }
                    if(i == n/2){

                        summ += a[i][j];
                        continue;
                    }
                    if(j == n/2){

                        summ += a[i][j];
                        continue;
                    }
                }
            }
            out.println(summ);
        }

        void maxHepify(int[] a, int i, int length){
        	int l = (i<<1) + 1;
        	int r = (i<<1) + 2;
        	int largest = i;
        	if(l < length && a[l] > a[largest])
        		largest = l;
        	if(r < length && a[r] > a[largest])
        		largest = r;
        	if(largest != i){
        		a[largest] += a[i];
        		a[i] = a[largest] - a[i];
        		a[largest] -= a[i];
        		maxHepify(a, largest, length);
        	}
        }

        void buildMaxHeap(int[] a){
        	for(int i = a.length/2 - 1; i >= 0; i--){
        		maxHepify(a, i, a.length);
        	}
        }

        void heapSort(int[] a){
        	buildMaxHeap(a);
        	for(int i = a.length - 1; i > 0; i--){
        		a[i] += a[0];
        		a[0] = a[i] - a[0];
        		a[i] -= a[0];
        		maxHepify(a, 0, i);
        	}
        }

        int[] zFunction(char[] s){
        	int[] z = new int[s.length];
        	z[0] = 0;
        	for (int i=1, l=0, r=0; i<s.length; ++i) {
        		if (i <= r)
        			z[i] = min (r-i+1, z[i-l]);
        		while (i+z[i] < s.length && s[z[i]] == s[i+z[i]])
        			++z[i];
        		if (i+z[i]-1 > r){
        			l = i;
        			r = i+z[i]-1;
        		}
        	}
        	return z;
        }

        int[] prefixFunction(char[] s){
        	int[] pr = new int[s.length];
        	for (int i = 1; i< s.length; ++i) {
        		int j = pr[i-1];
        		while (j > 0 && s[i] != s[j])
        			j = pr[j-1];
        		if (s[i] == s[j])  ++j;
        		pr[i] = j;
        	}
        	return pr;
        }

        int ModExp(int a, int n, int mod){
        	int res = 1;
        	while (n!=0)
        		if ((n & 1) != 0) {
        			res = (res*a)%mod;
        			--n;
        		}
        		else {
        			a = (a*a)%mod;
        			n >>= 1;
        		}
        	return res;
        }

        public static class Utils {

        	private Utils() {}

        	public static void mergeSort(int[] a) {
                    mergeSort(a, 0, a.length - 1);
            }

        	private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
                    final int MAGIC_VALUE = 50;
                    if (leftIndex < rightIndex) {
                            if (rightIndex - leftIndex <= MAGIC_VALUE) {
                                    insertionSort(a, leftIndex, rightIndex);
                            } else {
                                    int middleIndex = (leftIndex + rightIndex) / 2;
                                    mergeSort(a, leftIndex, middleIndex);
                                    mergeSort(a, middleIndex + 1, rightIndex);
                                    merge(a, leftIndex, middleIndex, rightIndex);
                            }
                    }
            }

            private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
            	int length1 = middleIndex - leftIndex + 1;
            	int length2 = rightIndex - middleIndex;
                int[] leftArray = new int[length1];
                int[] rightArray = new int[length2];
                System.arraycopy(a, leftIndex, leftArray, 0, length1);
                System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
                for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
                    if (i == length1) {
                            a[k] = rightArray[j++];
                    } else if (j == length2) {
                            a[k] = leftArray[i++];
                    } else {
                            a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
                    }
                }
            }

            private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
                for (int i = leftIndex + 1; i <= rightIndex; i++) {
            		int current = a[i];
                    int j = i - 1;
                	while (j >= leftIndex && a[j] > current) {
                        a[j + 1] = a[j];
                        j--;
                        }
                    a[j + 1] = current;
                }
            }
        }

        boolean isPrime(int a){
        	for(int i = 2; i <= sqrt(a); i++)
        		if(a % i == 0) return false;
        	return true;
        }

        static double distance(long x1, long y1, long x2, long y2){
        	return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        }

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

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

import java.util.Scanner;
public class scratch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int ara[][]=new int[n][n];
        int sum=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                ara[i][j]=scanner.nextInt();
            }
        }
        for(int i=0;i<n;i++)
        {
            for (int j=0;j<n;j++)
            {
                if(i==j)
                {
                    sum+=ara[i][j];
                }
            }
        }
        int x=(n-1)/2;
        for(int i=0;i<n;i++)
        {
            sum+=ara[i][x];
            if(i==x)
            {
                sum-=ara[i][x];
            }
        }
        for(int i=0;i<n;i++)
        {
            sum+=ara[x][i];
            if(i==x)
            {
                sum-=ara[x][i];
            }
        }
        int b=n-1;
        for(int i=0;i<n;i++)
        {
            sum+=ara[i][b];
            if(i==b)
            {
                sum-=ara[i][b];
            }
            b--;
        }
        System.out.println(sum);
        scanner.close();
    }
}

import java.util.*;
public class Main{
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int a[][] = new int[n][n];
		for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		a[i][j]=in.nextInt();
		int mid = (n-1)/2;
		int ans  = 0;
		for(int i=0;i<n;i++)
		if(i!=mid)
		ans+=a[mid][i]+a[i][mid];
		for(int i=0;i<n;i++){
		if(i!=mid){
			ans+=a[i][i]+a[i][n-i-1];
		}
		}
		ans+=a[mid][mid];
		System.out.print(ans);
	}
}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = Integer.parseInt(scan.nextLine());
        int[][]matrix = new int[n][n];
        for(int i = 0;i<n; i++){
            String[]str = scan.nextLine().split(" ");
            for(int j = 0; j<n;j++){
                matrix[i][j] = Integer.parseInt(str[j]);
            }
        }
        int sum = 0;
        int m = n/2;

        for(int i = 0; i<n; i++){
            sum += matrix[i][i];
            sum += matrix[i][n-1-i];
            sum += matrix[m][i];
            sum += matrix[i][m];
        }
        sum -= (3 * matrix[m][m]);
        System.out.println(sum);
    }
}

import java.util.Scanner;

public class GoodMatrixElements {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt(), sum = 0, b = n;
        int ara[][] = new int[n][n];

        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                ara[i][j] = s.nextInt();
                if(i==j||i==n/2||j==n/2||i==n-b&&j==b-1){
                        sum += ara[i][j];
                }
            }
            b--;
        }

        System.out.println(sum);
    }
}

import java.util.*;

public class Beaver {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int[][] array = new int[n][n];
        boolean[][] isCalculated = new boolean[n][n];
        int middle = (n-1)/2;

        for(int i = 0; i<n; i++) {
            for(int j=0; j<n; j++) {
                array[i][j] = s.nextInt();
            }
        }

        int sum = 0;
        int counter = 0;

        for(int i=0; i<n; i++) {
            if(isCalculated[i][counter]) {
                ++counter;
                continue;
            }
            sum += array[i][counter];
            isCalculated[i][counter] = true;
            ++counter;
        }
        counter=n-1;

        for(int i=0; i<n; i++) {

            if(isCalculated[i][counter]) {
                --counter;
                continue;
            }
            sum += array[i][counter];
            isCalculated[i][counter] = true;
            --counter;
        }
        counter=0;

        for(int i=middle-middle; i<n; i++) {
            if(isCalculated[middle][i]) continue;
            sum += array[middle][i];
            isCalculated[middle][i] = true;
        }

        for(int i=middle-middle; i<n; i++) {
            if(isCalculated[i][middle]) continue;
            sum += array[i][middle];
            isCalculated[i][middle] = true;
        }

        System.out.println(sum);
    }
}

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

public class matrix{

  public static void main(String args[]){

   Scanner in = new Scanner(System.in);
   int n,sum=0;
   n = in.nextInt();
   int[][] a = new int[n][n];
   int[][] flag = new int[n][n];

	for(int i=0;i<n;i++)
          for(int j=0;j<n;j++)
           { a[i][j]=in.nextInt();
             flag[i][j]=0;
           }

       for(int i=0;i<n;i++)
          for(int j=0;j<n;j++)
         {
            if(i==j && flag[i][j]==0)
                 {sum=sum+a[i][j];
                  flag[i][j]=1;}
            else if(i+j==n-1 && flag[i][j]==0)
                 { sum =sum+a[i][j];
                   flag[i][j]=1;}
            else if(i==n/2 && flag[i][j]==0)
                 {sum = sum+a[i][j];
 	          flag[i][j]=1;}
	   else if(j==n/2 && flag[i][j]==0)
                 { sum=sum+a[i][j];
                   flag[i][j]=1;}
         }

      System.out.println(sum);

}

}

import java.io.*;
import java.util.*;
public class GoodMatrixelements {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a[][] = new int[n][n];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                a[i][j] = sc.nextInt();
            }
        }
        int sum = 0;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if((i == (n-1)/2) || (j == (n-1)/2) || (i == j) || ((i+j) == (n-1))) {
                    sum += a[i][j];
                }
            }
        }
        System.out.println(sum);
    }
}

import java.util.Scanner;
public class Main
{
	static int[][] matrix=new int[105][105];
	static boolean[][] map=new boolean[105][105];
	public static void main(String[] args)
	{
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<n;j++)
			{
				matrix[i][j]=in.nextInt();
				map[i][j]=false;
			}
		}
		int sum=0;
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<n;j++)
			{
				if(map[i][j]==false&&(i==j||i+j==n-1||i==(n-1)/2||j==(n-1)/2))
				{
					sum+=matrix[i][j];
					map[i][j]=true;
				}
			}
		}
		System.out.println(sum);
	}
}

import java.util.Scanner;

public class Good_Matrix_Elements {

	public static void main(String[] args) {
		Scanner t = new Scanner(System.in);

		int n = t.nextInt();
		int sum = 0;
		int centre = 0;

		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				int a = t.nextInt();

				if (i == j)
					sum += a;
				if (i + j == n - 1)
					sum += a;
				if (i == n / 2)
					sum += a;
				if (j == n / 2)
					sum += a;
				if (i == j && i == n / 2)
					centre = a;
			}
		}

		System.out.println(sum - 3 * centre);

	}

}

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

public class ABBYY_A1 {

	/**
	 * @param args
	 * @throws IOException
	 * @throws NumberFormatException
	 */
	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int rows = Integer.parseInt(br.readLine());
		int sum = 0;
		for (int i = 0; i < rows; i++) {
			String[] str = br.readLine().split(" ");
			if (i == rows/2) {
				for (int j = 0; j < str.length; j++)
					sum += Integer.parseInt(str[j]);
			} else {
				sum += Integer.parseInt(str[i]);
				sum += Integer.parseInt(str[rows-i-1]);
				sum += Integer.parseInt(str[rows/2]);
			}
		} System.out.println(sum);
	}

}

import java.util.*;

public class A1_177 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum = 0;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++) {
                int a = sc.nextInt();
                if (i == j || i == n - 1 - j || i == n/2 || j == n/2)
                    sum += a;
            }
        System.out.print(sum);
    }
}

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int[][] x=new int[n][n];
		int all = 0;
		for(int i=0;i<n;i++)
			for(int j=0;j<n;j++)
				x[i][j] = sc.nextInt();

		for(int j=0;j<n;j++) {
			all+=x[n/2][j];
			all+=x[j][n/2];
			all+=x[j][j];
			all+=x[n-1-j][j];
		}
		all-=3*x[n/2][n/2];
		System.out.println(all);
	}
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int [][] values = new int [n][n];
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < n; j ++)
                values[i][j] = scanner.nextInt();
        int ans = 0;
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < n; j ++)
                if(j==i||j+i==n-1||i==n/2||j==n/2)
                    ans += values[i][j];
        System.out.println(ans);
    }
}

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

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

  static class TaskA2 {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
      int n = in.nextInt();

      int[][] grid = new int[n][n];

      for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
          grid[i][j] = in.nextInt();
        }
      }

      int answer = 0;

      int half = n / 2;
      for (int i = 0; i < n; i++) {
        if (i == half) {
          answer += grid[half][half];
        } else {
          answer += grid[half][i] + grid[i][half] + grid[i][i] + grid[i][n - i - 1];
        }
      }

      out.print(answer);
    }
  }
}

import java.io.*;
import java.util.*;
import java.lang.Math.*;
public class good
{
     public static void main(String args[])throws Exception
     {
         Scanner in=new Scanner(System.in);
         //BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         //BufferedReader br = new BufferedReader(new FileReader("good.in"));
         //PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("good.out")));
         PrintWriter pw = new PrintWriter(System.out);
         //StringTokenizer st;
         int n=in.nextInt();
         int i,j,k,l;
         int a[][]=new int[n][n];
         if(n==1)
         {
         pw.println(in.nextInt());
         pw.flush();
         System.exit(0);
        }
         for(i=0;i<n;i++)
         {
             for(j=0;j<n;j++)
             a[i][j]=in.nextInt();
         }
         int sum=0;
         for(j=0;j<n;j++)
         {
             sum+=a[n/2][j]+a[j][n/2]+a[j][j]+a[j][n-1-j];
            }
         pw.println(sum-3*(a[n/2][n/2]));
         pw.flush();
     }
}

import java.util.Scanner;

public class CodeForces
{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);

		int n = input.nextInt();
		int[][] array = new int[n][n];
		for (int i = 0; i < array.length; i++)
		{
			for (int j = 0; j < array[0].length; j++)
			{
				array[i][j] = input.nextInt();
			}
		}
		boolean[][] check = new boolean[n][n];
		for (int i = 0; i < array.length; i++)
		{
			for (int j = 0; j < array[0].length; j++)
			{
				if (i == j)
				{
					check[i][j] = true;
				}
				if (i + j == n - 1)
				{
					check[i][j] = true;
				}
				if (i == (n - 1) / 2)
				{
					check[i][j] = true;
				}
				if (j == (n - 1) / 2)
				{
					check[i][j] = true;
				}
			}
		}
		int sum = 0;
		for (int i = 0; i < array.length; i++)
		{
			for (int j = 0; j < array[0].length; j++)
			{
				if (check[i][j])
				{
					sum += array[i][j];
				}
			}
		}
		System.out.println(sum);
	}
}

import java.util.Scanner;
public class matrix{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a[][]=new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                a[i][j]=s.nextInt();
            }
        }
        int sum=0,k=n-1;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if((i==j)||(j==k)){
                    sum=sum+a[i][j];
                }
                else if((i==(n-1)/2)||(j==(n-1)/2)){
                    sum=sum+a[i][j];
                }
            }
            k--;
        }
        System.out.print(sum);
    }
}

import java.util.*;
public class ABA {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N =  sc.nextInt();
		int[][] array = new int[N][N];
		boolean[][] B = new boolean[N][N];
		long ans = 0;
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				array[a][b]=sc.nextInt();
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==b){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==(N-1-b)){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			//for(int b=0;b<N;b++){
			int b = N/2;

					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}

		for(int a=0;a<N;a++){
		//for(int b=0;b<N;b++){
		int b = N/2;

				if(!B[b][a]){
					B[b][a]=true;
					ans+=array[b][a];
				}
			}

		System.out.println(ans);

	}

}

import java.util.Scanner;

public class CF2 {
    Scanner inputScan = new Scanner(System.in);
    int[][] mat;
    public static void main(String[] args) {
        CF2 program = new CF2();
        program.execute();
    }

    public void execute()
    {
        int N = inputScan.nextInt();
        mat = new int[N][N];
        int result = 0, input;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                input = inputScan.nextInt();
                if(i==j) result += input;
                else if(i == (N-j-1)) result += input;
                else if(i == (N/2)) result += input;
                else if(j == (N/2)) result += input;
            }
        }
        System.out.println(result);
    }
}

    import java.util.Scanner;
import java.util.Scanner;

    public class A2 {

        public static void main(String[] args) {
            Scanner in=new Scanner(System.in);
            int i,j,k,n,f;
            long s;
            int[][] a=new int[1000][1000];
            n=in.nextInt();
            for(i=0;i<n;i++){
                for(j=0;j<n;j++){
                    a[i][j]=in.nextInt();
                }
            }
            s=0;
            for(i=0;i<n;i++){
                s+=a[i][i];
                a[i][i]=0;
            }
            j=n-1;
            for(i=0;i<n;i++){
                s+=a[i][j];
                a[i][j]=0;
                j--;
            }
            for(i=0;i<n;i++){
                s+=a[i][((n-1)/2)];
                a[i][((n-1)/2)]=0;
            }
            for(i=0;i<n;i++){
                s+=a[((n-1)/2)][i];
                a[((n-1)/2)][i]=0;
            }
            System.out.println(s);
        }

    }

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

public class Main {

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

    StringTokenizer str = null;
    BufferedReader in;
    PrintWriter out;

    void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));
        solve();
        out.flush();
        out.close();
    }

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

    String nextToken() throws IOException {
        if (str == null || !str.hasMoreElements()) {
            str = new StringTokenizer(nextString());
        }
        return str.nextToken();
    }

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

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

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

    class Point implements Comparable<Point> {
        int x;
        int y;

        @Override
        public int compareTo(Point p) {
            if (p.x > x)
                return -1;
            if (p.x < x)
                return 1;
            if (p.y > y)
                return -1;
            if (p.y < y)
                return 1;
            return 0;
        }
    }

    private double Rastoyanie(Point p[], int i, int l) {
        int xx = p[i].x - p[l].x;
        int yy = p[i].y - p[l].y;
        xx = xx * xx;
        yy = yy * yy;
        return Math.sqrt(xx + yy);
    }

    private boolean Na_odnoy_pramoy(Point p[], int i, int j, int l) {
        return (p[i].y - p[j].y) * p[l].x + (p[j].x - p[i].x) * p[l].y
                + (p[i].x * p[j].y - p[j].x * p[i].y) == 0;
    }

    int n;
    int a[][];
    boolean f[][];

    void solve() throws IOException {
        n = nextInt();
        a = new int[n][n];
        f = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = nextInt();
                f[i][j] = false;
            }
        }
        int k = (n - 1) / 2;
        for (int i = 0; i < n; i++) {
            f[i][i] = true;
            f[n - 1 - i][i] = true;
            f[i][k] = true;
            f[k][i] = true;
        }
        int s = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (f[i][j])
                    s += a[i][j];
            }
        }
        out.println(s);

    }

}

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

public class CF177A2
{
	public static void main (String[]args) throws Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		int m = ((n-1)/2) + 1;
		int ans = 0;
		for(int i = 1, c = n ; i <= n; i++,c--){
			StringTokenizer st = new StringTokenizer(br.readLine());
			for(int j = 1;j <= n; j++){
				int x = Integer.parseInt(st.nextToken());
				if(i == j || j == c || i == m || j == m)
					ans += x;
			}
		}
		System.out.println(ans);

	}
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }
        int subCount = 0;
        if (n != 1) {
            for (int i = 0; i < matrix.length; i++) {
                subCount += matrix[i][i];
                for (int j = 0; j < n; j++) {
                    if (i == n - j - 1) {
                        subCount += matrix[i][j];
                    }
                }
                subCount += matrix[i][n / 2];
                subCount += matrix[n / 2][i];

            }
            System.out.println(subCount - (3 * matrix[n / 2][n / 2]));

        } else {
            System.out.println(matrix[0][0]);
        }

    }
}

import java.util.*;

/*
 *
 *	A1.java
 *	Written by Andy Huang: 11:55:27 AM Apr 21, 2012
 */
public class A1 {
	static void solve() {
		int n = in.nInt();
		int sum = 0;
		for(int i = 0; i < n; i++){
			for(int j =0; j < n; j++){
				if (i == j || n-j-1 == i || i == n/2 || j == n/2)
					sum += in.nInt();
				else
					in.nInt();
			}
		}
		out.appendln(sum);
	}

	public static void main(String[] args) {
		in = new Input();
		out = new Output();
		solve();
		out.print();
	}

	static Output out;
	static Input in;

	static void pln(Object o) {
		System.out.println(o);
	}

	static void pf(Object o) {
		System.out.print(o);
	}

}

final class Input {
	private java.io.BufferedReader reader;
	private java.util.StringTokenizer tokenizer;

	public Input() {
		reader = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
		tokenizer = null;
	}

	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new java.util.StringTokenizer(reader.readLine());
			}
			catch (java.io.IOException e) {
				throw new RuntimeException("I/O Error");
			}
		}
		return tokenizer.nextToken();
	}

	public String nLine() {
		try {
			return reader.readLine();
		}
		catch (java.io.IOException e) {
			throw new RuntimeException(e);
		}
	}

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

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

	public double nDouble() {
		return Double.parseDouble(next());
	}

}
final class Output {
	public StringBuilder buffer;

	Output() {
		buffer = new StringBuilder();
	}

	Output(int size) {
		buffer = new StringBuilder(size);
	}

	void print() {
		System.out.print(buffer.toString());
	}

	void flush() {
		System.out.flush();
	}

	<T> void append(T obj) {
		buffer.append(obj);
	}

	<T> void appendln(T obj) {
		append(obj);
		append('\n');
	}

	void delete(int index) {
		buffer.deleteCharAt(index);
	}

}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[][] matrix = new int[n][n];
		int sum = 0;

		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				matrix[i][j] = in.nextInt();
				if (n == 5) {
					if (i == 0) {
					if (j == 1 || j == 3) {
						matrix[i][j] = 0;
					}
				}
				if (i == 1) {
					if (j == 0 || j == 4) {
						matrix[i][j] = 0;
					}
				}
				if (i == 3) {
					if (j == 0 || j == 4) {
						matrix[i][j] = 0;
					}
				}
				if (i == 4) {
					if (j == 1 || j == 3) {
						matrix[i][j] = 0;
					}
				}
				}
				sum += matrix[i][j];
			}
		}
		System.out.println(sum);
	}
}

import java.util.Scanner;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

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

class TaskA {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
        int n=in.nextInt(),i,j;
        int a[][]=new int[n][n];
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                a[i][j]=in.nextInt();
            }
        }
        long c=0;
        for(i=0;i<n;i++)
        {
            if(i==(n-1)/2)
                continue;
            c+=a[(n-1)/2][i];
            c+=a[i][(n-1)/2];
        }
        System.out.println(c);
        int p=n;
        for(i=0;i<n;i++)
        {
            p--;
            if(i==(n-1)/2)
                continue;
            c+=a[i][i];
            c+=a[i][p];

            System.out.println(c);
        }
        c+=a[(n-1)/2][(n-1)/2];
        out.println(c);
	}
}

import java.io.*;
import java.util.*;
public class GelMat{
    public static void main(String[] args){
	int n;// size of matrix
	int sumEl=0;
	int El=0;
	int middle=0;
	System.out.println("Enter the range of matrix, it should be odd");
	Scanner in=new Scanner(System.in);
	n=in.nextInt();
	while ((n%2)==0){
	    System.out.println("The value should be odd");
	    n=in.nextInt();
	};
	middle=(n-1)/2+1;
	int[][] SqMatrix=new int[n][n];
	 System.out.println("Enter the matrix element");
	for(int i=1;i<=n;i++){
	    for(int j=1;j<=n;j++){
	     El=in.nextInt();
	     while(!((El>=0)&&(El<=100))){
	        System.out.println("Range should be between 0 and 100");
	        El=in.nextInt();
	     }
	     if((i==j)||(i==middle)||(j==middle)||(j==(n-i+1))){
	       sumEl+=El;
	       System.out.println(i+" "+j);
	     }
	    }
	}
	System.out.println(sumEl);

    }
}

import java.util.*;

public class cf171a {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		StringBuilder sb = new StringBuilder(in.next().trim());
		System.out.println(a + Integer.parseInt(sb.reverse().toString()));
	}
}

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

public class prob {

    static Scanner sc;
    static PrintWriter pw;
    static int[][] a;
    static int n;

    public static void main(String[] args) {
        sc = new Scanner(System.in);
        pw = new PrintWriter(System.out);
        try{
            n = sc.nextInt();
            a = new int[n][n];
            for(int i = 0; i < n; i++)
                for(int j = 0; j < n; j++)
                    a[i][j] = sc.nextInt();
            if(n == 1) {
                pw.println(a[0][0]);
                return;
            }
            long s = 0;
            for(int i = 0; i < n; i++)
                s += a[i][i] + a[n - i - 1][i] +
                    a[(n - 1) / 2 + 1][i] + a[i][(n - 1) / 2 + 1];
            s -= 3 * a[(n - 1) / 2 + 1][(n - 1) / 2 + 1];
            pw.println(s);
        }
        finally {
            pw.close();
        }
    }
}

import java.util.*;
public class ABA {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N =  sc.nextInt();
		int[][] array = new int[N][N];
		boolean[][] B = new boolean[N][N];
		long ans = 0;
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				array[a][b]=sc.nextInt();
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==b){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==(N-1-b)){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			//for(int b=0;b<N;b++){
			int b = N/2;

					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}

		for(int a=0;a<N;a++){
		//for(int b=0;b<N;b++){
		int b = N/2;

				if(!B[b][a]){
					B[a][b]=true;
					ans+=array[a][b];
				}
			}

		System.out.println(ans);

	}

}

import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class ABYE{
    static BufferedReader br;
    public static void main(String args[])throws Exception{
        br=new BufferedReader(new InputStreamReader(System.in));
        int n=toInt();
        int b[][]=new int[n][n];
        int mid=(n+1)/2-1;
        for(int i=0;i<n;i++){
            String st[]=toStrArray();
            for(int j=0;j<st.length;j++){
                b[i][j]=Integer.parseInt(st[j]);
            }
        }
        int sum=0;
        for(int i=0;i<n;i++){
            sum+=b[i][i];
        }
        for(int i=0;i<n;i++){
            if(i==mid)continue;
            sum+=b[i][n-1-1];
        }

        for(int i=0;i<n;i++){
            if(i==mid)continue;
            sum+=b[i][mid];
        }

        for(int i=0;i<n;i++){
            if(i==mid)continue;
            sum+=b[mid][i];
        }
        System.out.println(sum);

    }

    /****************************************************************/
    public static int[] toIntArray()throws Exception{
       String str[]=br.readLine().split(" ");
       int k[]=new int[str.length];
       for(int i=0;i<str.length;i++){
            k[i]=Integer.parseInt(str[i]);
       }
       return k;
    }
    public static int toInt()throws Exception{
       return Integer.parseInt(br.readLine());
    }
    public static long[] toLongArray()throws Exception{
       String str[]=br.readLine().split(" ");
       long k[]=new long[str.length];
       for(int i=0;i<str.length;i++){
            k[i]=Long.parseLong(str[i]);
       }
       return k;
    }
    public static long toLong()throws Exception{
       return Long.parseLong(br.readLine());
    }
    public static double[] toDoubleArray()throws Exception{
       String str[]=br.readLine().split(" ");
       double k[]=new double[str.length];
       for(int i=0;i<str.length;i++){
            k[i]=Double.parseDouble(str[i]);
       }
       return k;
    }
    public static double toDouble()throws Exception{
       return Double.parseDouble(br.readLine());
    }
    public static String toStr()throws Exception{
       return br.readLine();
    }
    public static String[] toStrArray()throws Exception{
       String str[]=br.readLine().split(" ");
       return str;
    }
    /****************************************************************/

}

import java.util.Scanner;

public class A1 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int units[][] = new int[n][n];
        int sum = 0;
        //in.next();
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++){
                //System.out.println("i: " + i + " j: " + j);
                if ((i == j) || (i == (n-j+1)) || (i == (n/2 + 1)) || (j == (n/2 + 1))){
                    int tmp = in.nextInt();
                    //System.out.println("Unit: " + tmp);
                    sum += tmp;
                }
            }

        System.out.println(sum);
    }
}

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

public class CP {
	public static void main(String[] args) {
		Scanner sc = new Scanner (System.in);
		int n = sc.nextInt();
		int[][] array = new int[n][n];
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				array[i][j] = sc.nextInt();
			}
		}
		int ans = 0;
		// Middle Rows
		for(int i = 0; i < n; i++) {
			ans += array[n / 2][i];
		}
		// Middle cols
		for(int i = 0; i < n; i++) {
			ans += array[i][n/ 2];
		}
		for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(i == j || Math.max(i, j) + Math.min(i, j) == n - 1) {
                    ans += array[i][j];
                    System.out.println(i + " " + j);
				}
			}
		}
		System.out.println(ans - 2 * array[n / 2][n / 2]);
	}
}

//package com.baba;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int[][] mat = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                mat[i][j] = s.nextInt();
            }
        }
        int sum = 0;
        for (int i = 0; i < n; i++) {
            if (i != n / 2) {
                sum += mat[i][i];
            }
        }
        for (int i = n - 1; i >= 0; i--) {
            if (i != n / 2) {
                sum += mat[i][i];
            }
        }
        for (int i = 0; i < n; i++) {
            if (i != n / 2) {
                sum += mat[i][n / 2];
                sum += mat[n / 2][i];
            }
        }
        sum += mat[n / 2][n / 2];
        System.out.println(sum);
    }

}

import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int[][] x=new int[n][n];
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				x[i][j]=sc.nextInt();
			}
		}
		int a=0,b=n-1,sum=0;
		while(a<n){
			sum+=x[a][a];
			a++;
		}
		while(b>=0){
			sum+=x[b][b];
			b--;
		}
		for(int i=0;i<n;i++){
			sum+=x[n/2][i];
			sum+=x[i][n/2];
		}
		System.out.print(sum-x[n/2][n/2]*3);

	}
}

import java.util.*;
// warm-up
public class GoodMatrixElements {

	static void solve() {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(),t=0,m=n>>1;
		int[][] a = new int[n][n];
		for (int i=0; i<n; i++) {
			for (int j=0; j<n; j++) {
				a[i][j]=sc.nextInt();
			}
		}
		for (int i=0,j=0; i<n; i++,j++) {
			if(i!=m && j!=m) t+=a[i][j];
		}
		for (int i=n-1,j=n-1; i>=0; i--,j--) {
			if(i!=m && j!=m) t+=a[i][j];
		}
		for (int j=0; j<n; j++) if(j!=m) t+=a[m][j];
		for (int j=0; j<n; j++) if(j!=m) t+=a[j][m];
		t+=a[m][m];
		System.out.println(t);
		sc.close();
	}

	public static void main(String args[]) {
		solve();
	}

}

import java.util.*;
public class matrix1
{
	public static void main(String[] args) {
		int n,sum=0,i,j,r=0,total=0;
		Scanner sc = new Scanner(System.in);
		n=sc.nextInt();
		int a[][]=new int[n][n];
		for(i=0;i<n;i++)
		{
			for(j=0;j<n;j++)
			{
				a[i][j]=sc.nextInt();
			}
		}
		for(i=0;i<n;i++)
		{
			sum+=a[i][i];
		}
		for(i=(n-1);i>=0;i--)
		{
			sum+=a[i][i];
		}
		r=(n-1)/2;
		for(i=0;i<n;i++)
		{
			sum+=a[i][r];
			sum+=a[r][i];
		}
	  total = sum-(a[r][r]*3);
	  System.out.println(total);
	}
}

import java.util.Scanner;

public class Main {
    public static int rows;
    public static int[][] squareArray;
    public static int sum;

    public static void main(String[] args) {
        Scanner inputReader = new Scanner(System.in);
        rows = Integer.parseInt(inputReader.nextLine());
        squareArray = new int[rows][rows];
        for (int row = 0; row < rows; row++) {
            for (int column = 0; column < rows; column++) {
                squareArray[row][column] = inputReader.nextInt();
            }
        }
        sum = 0;
        printSquareArray();

        findVertical();
        System.out.println("After vertical " + sum);
        findHorizontal();
        findOverlap();
        findPrimaryDiagonal();
        findSecondaryDiagonal();
        System.out.println("After= " + sum);

    }

    public static void printSquareArray() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < rows; j++) {
                System.out.print(squareArray[i][j]);
            }
            System.out.println();
        }
    }

    public static void findVertical() {

        int middleColumn = (rows / 2); //(row/2)+1-1
        for (int row = 0; row < rows; row++) {
            System.out.println("+" + squareArray[row][middleColumn]);
            sum += squareArray[row][middleColumn];
        }
        System.out.println("sum=" + sum);
    }

    public static void findHorizontal() {
        int middleRow = (rows / 2); //(row/2)+1-1
        for (int column = 0; column < rows; column++) {
            System.out.println("+" + squareArray[middleRow][column]);
            sum += squareArray[middleRow][column];
        }
        System.out.println("sum=" + sum);
    }

    public static void findPrimaryDiagonal() {
        for (int i = 0; i < rows; i++) {
            System.out.println("+" + squareArray[i][i]);
            sum += squareArray[i][i];
        }
        System.out.println("sum=" + sum);

    }

    public static void findSecondaryDiagonal() {
        for (int i = 0; i < rows; i++) {
            sum += squareArray[i][rows - i - 1];
            System.out.println("+" + squareArray[i][rows - i - 1]);

        }
        System.out.println("sum=" + sum);
    }

    public static void findOverlap() {
        sum -= (3 * squareArray[rows / 2][rows / 2]);
        System.out.println("-" + (3 * squareArray[rows / 2][rows / 2]));
        System.out.println("sum=" + sum);
    }
}

import java.util.*;
public class GoodMatrixElements{
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		int sum = 0;
		int n = sc.nextInt();
		for(int i = 0;i<n;i++)
		{
		for(int j = 0;j<n;j++)
			{
				int curr = sc.nextInt();
				if(j==i||j==n/2||i==n/2||i+j==n-1)
				{
					sum = sum + curr;
					System.out.println(i + " "+j);
				}
			}
		}
		System.out.println(sum);
	}
}

import java.util.Arrays;
import java.util.Scanner;

/**
 *
 * @author Nijat
 */
public class GoodInMatrix {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        int[][] s = new int[n][n];
        int nn = 0;
        while(nn < n)
        {
            String[] ss = in.nextLine().split(" ");
            for(int i = 0; i < n; ++i)
            {
                s[nn][i] = Integer.parseInt(ss[i]);
            }
            ++nn;
        }

//System.out.println(Arrays.deepToString(s));

        int middle = s[0][0];
        int sum = 0;
        int z = 0;
        if (n == 1)
        {
        sum = middle;
        }
        if (n != 1)
        {
        middle = s[(n+1)/2][(n+1)/2];

        while(z<n)
        {
            sum += s[z][z];
            sum += s[(n+1)/2][z];
            sum += s[z][(n+1)/2];
            sum += s[n-1-z][z];
            z+=1;
        }
        sum -= middle * 3;
        }

        System.out.println(sum);

    }
}

import java.io.BufferedReader;
import java.io.IOError;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;

public class Main {
 public static void main(String[] args) throws IOException
 {
	 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	 int n = Integer.parseInt(in.readLine());
	 int[][] ar = new int[101][101];
	 String[] temp;
	 for (int i=0; i<n; i++)
	 {
		 temp = in.readLine().split(" ");
		 for (int j=0; j<n; j++)
		 {
			 ar[i][j] = Integer.parseInt(temp[j]);
		 }
	 }
	 int sum=0;
	 for (int i=0; i<n; i++)
	 {
		 for (int j=0; j<n; j++)
		 {
			 if(i==j)
			 {
				 sum+=ar[i][j];
			 }
			 if(i==n-j-1)
			 {
				 sum+=ar[i][j];
			 }
			 if(i==((n/2)+1))
			 {
				 sum+=ar[i][j];
			 }
			 if(j==((n/2)+1))
			 {
				 sum+=ar[i][j];
			 }
		 }
	 }
	 System.out.println(sum-3*(ar[n/2+1][n/2+1]));

 }
}

import java.io.BufferedReader;
import java.io.IOError;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;

public class Main {
 public static void main(String[] args) throws IOException
 {
	 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	 int n = Integer.parseInt(in.readLine());
	 int[][] ar = new int[102][102];
	 String[] temp;
	 for (int i=0; i<n; i++)
	 {
		 temp = in.readLine().split(" ");
		 for (int j=0; j<n; j++)
		 {
			 ar[i][j] = Integer.parseInt(temp[j]);
		 }
	 }
	 int sum=0;
	 if(n==1)
	 {
		 System.out.print(ar[0][0]);
		 return;
	 }
	 for (int i=0; i<n; i++)
	 {
		 for (int j=0; j<n; j++)
		 {
			 if(i==j)
			 {
				 sum+=ar[i][j];
			 }
			 if(i==n-j-1)
			 {
				 sum+=ar[i][j];
			 }
			 if(i==((n/2)+1))
			 {
				 sum+=ar[i][j];
			 }
			 if(j==((n/2)+1))
			 {
				 sum+=ar[i][j];
			 }
		 }
	 }
	 System.out.println(sum-3*(ar[n/2+1][n/2+1]));

 }
}

import java.io.BufferedReader;
import java.io.IOError;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;

public class Main {
 public static void main(String[] args) throws IOException
 {
	 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	 int n = Integer.parseInt(in.readLine());
	 int[][] ar = new int[102][102];
	 String[] temp;
	 for (int i=0; i<n; i++)
	 {
		 temp = in.readLine().split(" ");
		 for (int j=0; j<n; j++)
		 {
			 ar[i][j] = Integer.parseInt(temp[j]);
		 }
	 }

	 int sum=0;
	 if(n==1)
	 {
		 System.out.print(ar[0][0]);
		 return;
	 }
	 for (int i=0; i<n; i++)
	 {
		 for (int j=0; j<n; j++)
		 {
			 if(i==j)
			 {
				 sum+=ar[i][j];
			 }
			 if(i==n-j-1)
			 {
				 sum+=ar[i][j];
			 }
			 if(i==((n/2)+1))
			 {
				 sum+=ar[i][j];
			 }
			 if(j==((n/2)+1))
			 {
				 sum+=ar[i][j];
			 }
		 }
	 }
	 System.out.println(sum-3*(ar[n/2][n/2]));

 }
}

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

public class Main {

    static BufferedReader br;
    static PrintWriter out;
    static StringTokenizer st;

    static void solve() throws Exception {
        int n = nextInt();
        int[][] a = new int[n][n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                a[i][j] = nextInt();
            }
        }
        int sum = 0;
        for(int i = 0; i < n; i++){
            sum += a[i][i] + a[n - i - 1][i];
            if(n > 1 && n % 2 != 0){
                sum += a[n / 2][i] + a[i][n / 2];
            }
        }
        if(n > 1 && n % 2 != 0){
            sum -= 3 * a[n/2][n/2];
        }
        out.println(sum);
    }

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

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

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

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) {
                return null;
            }
            st = new StringTokenizer(line);
        }
        return st.nextToken();
    }

    public static void main(String[] args) {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new PrintStream(System.out));
            solve();
            out.close();
            br.close();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

}

              //package main;
import java.io.*;
import java.math.*;
import java.util.*;
import java.awt.*;
/**
*
* @author Togrul Gasimov (ttogrul30@gmail.com)
*
*/

public class Main {
public static void main(String[] args) /*throws FileNotFoundException*/ {
   InputStream inputStream = System.in;
   OutputStream outputStream = System.out;
   FastScanner in = new FastScanner(inputStream);
   FastPrinter out = new FastPrinter(outputStream);
   TaskB solver = new TaskB();
   solver.solve(1, in, out);
   out.close();
}
}

class TaskB{

public void solve(int testNumber, FastScanner scan, FastPrinter out) /*throws FileNotFoundException*/ {
   //Scanner sscan = new Scanner(new File("input.txt"));
   //PrintStream oout = new PrintStream(new File("output.txt"));
   int n = scan.nextInt();
   int[][] a = new int[n][n];
   int ans = 0;
   for(int i = 0; i < n; i++){
       for(int j = 0; j < n; j++){
           a[i][j] = scan.nextInt();
           if(i != j || i + j == n - 1 || i == n / 2 || j == n / 2 ){
               ans += a[i][j];
           }
       }
   }
   out.println(ans);
   //sscan.close();
   //oout.close();
}
}

class FastScanner extends BufferedReader {
public FastScanner(InputStream is) {
   super(new InputStreamReader(is));
}

public int read() {
   try{
       int ret = super.read();
       return ret;
   }catch(Exception e){
       throw new InputMismatchException();
   }
}

public String next() {
   StringBuilder sb = new StringBuilder();
   int c = read();
   while (isWhiteSpace(c)) {
       c = read();
   }
   if (c < 0) {
       return null;
   }
   while (c >= 0 && !isWhiteSpace(c)) {
       sb.appendCodePoint(c);
       c = read();
   }
   return sb.toString();
}

static boolean isWhiteSpace(int c) {
   return c >= 0 && c <= 32;
}

public int nextInt() {
   int c = read();
   while (isWhiteSpace(c)) {
       c = read();
   }
   int sgn = 1;
   if (c == '-') {
       sgn = -1;
       c = read();
   }
   int ret = 0;
   while (c >= 0 && !isWhiteSpace(c)) {
       if (c < '0' || c > '9') {
           throw new NumberFormatException("digit expected " + (char) c
                   + " found");
       }
       ret = ret * 10 + c - '0';
       c = read();
   }
   return ret * sgn;
}

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

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

public BigInteger nextBigInteger() {
   return new BigInteger(next());
}

public BigDecimal nextBigDecimal(){
   return new BigDecimal(next());
}

public String readLine(){
   try{
       return super.readLine();
   }catch(IOException e){
       return null;
   }
}
}

class FastPrinter extends PrintWriter {

public FastPrinter(OutputStream out) {
   super(out);
}
public FastPrinter(Writer out) {
   super(out);
}
}

import java.util.Scanner;

public class Easy {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[][] arr = new int[n][n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				arr[i][j] = sc.nextInt();
			}
		}
		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum += arr[i][i];
			sum += arr[n - i - 1][n - i - 1];
			sum += arr[(n - 1) / 2][i];
			sum += arr[i][(n - 1) / 2];
		}
		sum -= arr[(n - 1) / 2][(n - 1) / 2] * 3;
		if (n == 1)
			System.out.println(0);
		else
			System.out.println(sum);

		sc.close();
	}
}

import java.util.Scanner;

public class Easy {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for (int i = 0 ; i < n ; i++) {
            for (int j = 0 ; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int sum = 0;
        for (int i = 0 ; i < n ; i++) {
            sum += arr[i][i];
            sum += arr[n-i-1][n-i-1];
            sum += arr[(n-1)/2][i];
            sum += arr[i][(n-1)/2];
        }
        sum -= arr[(n-1)/2][(n-1)/2] * 3;

        System.out.println(sum);

        sc.close();
    }
}

import java.util.Scanner;
public class java1
{
 public static void main(String args[])
    {
     Scanner sc=new Scanner(System.in);
     System.out.println("Enter order of the square matrix");
     int n=sc.nextInt();
     int c=0;
     if(n%2!=0)
     {
     int a[][]=new int[n][n];
     int i,j;
     System.out.println("Enter the elements of matrix");
     for(i=0;i<n;i++)
           {
            for(j=0;j<n;j++)
              {
               a[i][j]=sc.nextInt();
               if(i==j)
                c+=a[i][j];
              }
           }

     i=(n-1)/2;
for( j=0;j<n;j++)
      {
	if(i!=j)
	c+=a[i][j]+a[j][i];
      }
  i=0;
  j=n-1;
   while(i<n && j>=0)
   {
     if(i!=j)
     c+=a[i][j];
    j--;
    i++;
    }

   System.out.println("The sum of good matrix elements is ="+c);

   }

else
System.out.println("The order of matrix is ought to be odd");

 }
}

import java.util.*;

public class A177 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();

		int[][] ar = new int[n][n];

		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				ar[i][j] = scan.nextInt();
			}
		}

		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum += ar[i][i];
			sum += ar[n - 1 - i][n - 1 - i];
			sum += ar[i][n / 2];
			sum += ar[n / 2][i];
		}

		sum -= 3 * ar[n / 2][n / 2];

		System.out.print(sum);
	}

}

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

public class A1_177 {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(in.readLine());
		int[][] p = new int[n][n];
		for(int i = 0;i<n;i++) {
			String[] temp = in.readLine().split(" ");
			for(int j = 0;j<temp.length;j++) {
				p[i][j] = Integer.parseInt(temp[j]);
			}
		}
		int c  = 0;
		for(int i = 0;i<n;i++) {
			for(int j = 0;j<n;j++) {
				if(i == j) {
					c += p[i][j];
				} else if(i == n - j - 1) {
					c += p[i][n - j - 1];
				} else if(i == n / 2) {
					c += p[i][j];
				} else if(j == n / 2) {
					c += p[i][j];
				}
			}
		}
		System.out.println(c);
	}
}

import java.util.*;
public class goodmatrix
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m[][]=new int[n][n];
        int i,j,s=0;
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                m[i][j]=sc.nextInt();
                if((i==j)&&((i+j)==(n-1)))
                s=s+m[i][j];

            }
        }
        for(i=0;i<n;i++)
        {
            if(i!=(n/2))
            s=s+m[n/2][i];
        }
        for(i=0;i<n;i++)
        {   if(i!=(n/2))
            s=s+m[i][n/2];
        }
            System.out.println(s);

    }}

import java.util.*;
public class goodmatrix
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m[][]=new int[n][n];
        int i,j,s=0;
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                m[i][j]=sc.nextInt();
                if((i==j)&&((i+j)==(n-1)))
                s=s+m[i][j];
                if(i==((n-1)/2))
                {
                    if(j!=((n-1)/2))
                    s=s+m[i][j];
                }
                if(j==((n-1)/2))
                {
                    if(i!=((n-1)/2))
                    s=s+m[i][j];
                }
            }
        }
    }}

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

		java.util.Scanner scan=new java.util.Scanner(System.in);
		int n=scan.nextInt();
		int [][]arr=new int[n][n];
		for(int i=1;i<=arr.length;i++){
			for(int j=1;j<=arr.length;j++){
				arr[i-1][j-1]=scan.nextInt();
			}
		}
		long sum=0;
		for(int i=1;i<=arr.length;i++){
			sum+=arr[i-1][i-1];
			sum+=arr[arr.length-i][arr.length-i];
		}
		//System.out.println("sum: "+sum);
		for(int i=1;i<=arr.length;i++){
			sum+=arr[arr.length/2][i-1];
			sum+=arr[i-1][arr.length/2];
		}
		sum-=3*arr[arr.length/2][arr.length/2];
		//System.out.println("sum: "+sum);
		System.out.println(sum);
	}
}

import java.io.IOException;

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

import java.io.PrintWriter;

import java.util.StringTokenizer;

import java.util.Queue;

public class Main {

    static Scanner s = new Scanner();
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException {
        int n = s.nextInt(), j = n / 2, t = 0;
        for(int i = 0, k = n-1; i < n; i++, k--)
            for(int l = 0; l < n; l++)
                if(i == j || l == i || l == j || l == k)
                    t += s.nextInt();
        out.print(t);
        out.close();
    }

    static class Scanner {
        BufferedReader in;
        StringTokenizer s;

        public Scanner() {
            in = new BufferedReader(new InputStreamReader(System.in));
            s = new StringTokenizer("");
        }

        public String nextToken() throws IOException {
            if(!s.hasMoreTokens())
                s = new StringTokenizer(in.readLine());
            return s.nextToken();
        }

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

import java.io.*;
public class good
{
 public static void main(String args[])throws IOException
 {
  InputStreamReader read=new InputStreamReader(System.in);
  BufferedReader in=new BufferedReader(read);
  int i,j,n,r,s;
  r=s=0;
  String st;
  n=Integer.parseInt(in.readLine());
  int[][] a=new int[n][n];
  for(i=0;i<n;i++)
  {
   st=in.readLine();
   r=0;
   for(j=0;j<st.length();j++)
   {
    if(st.charAt(j)==' ')
    {
     a[i][r++]=Integer.parseInt(st.substring(0,j));
     st=st.substring(j+1);
     j=-1;
    }
   }
  }
  for(i=0;i<n;i++)
  {
   for(j=0;j<n;j++)
   {
    if(i==j || (i+j)==(n-1) || i==(n-1)/2 || j==(n-1)/2)
    s+=a[i][j];
   }
  }
  System.out.println(s);
 }
}

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

public class Main {
	public static void main(String[] args){
		solution s = new solution();
		s.solve();
		s.close();
	}
}

interface IO{
	Scanner in = new Scanner(new BufferedInputStream(System.in));
	PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
}

class solution implements IO{

	final int MAXN = (int) 1e2+5;
	int [][] a = new int[MAXN][MAXN];

	void solve(){

		int n = in.nextInt();
		long sum = 0;
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++){
				a[i][j] = in.nextInt();
				if(i == j || i == n - j + 1 || i == (n + 1) / 2 || j == (n + 1) / 2){
					sum += a[i][j];
					out.println(a[i][j]);
				}
			}
		out.println(sum);
	}

	void close(){
		in.close();
		out.close();
	}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();
   int c=0,mid=0;
   mid=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==0||j==0||i==n-1||j==n-1)
           c+=arr[i][j];
         }
   }
   c+=arr[mid][mid];
       System.out.print(c);

}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();

   int c=0,mid=0;
   mid=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   if(n==1){
      System.out.print(arr[0][0]);
      return;
   }

   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==0||j==0||i==n-1||j==n-1)
           c+=arr[i][j];
         }
   }
   c+=arr[mid][mid];
       System.out.print(c);

}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();

   int c=0,mid=0;
   mid=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   if(n==1){
      System.out.print(arr[0][0]);
      return;
   }

   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==0||j==0)
           c+=arr[i][j];
         }
   }
   c+=arr[mid][mid];
       System.out.print(c);

}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();
   int c=0,m;
   m=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==j||j==0||i==m||j==m||i+j<n-1)
           c+=arr[i][j];
           }
   }
       System.out.print(c);

}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();
   int c=0,m;
   m=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==j||i==m||j==m||i+j<(n-1))
           c+=arr[i][j];
           }
   }
       System.out.print(c);

}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();
   int c=0,mid=0;
   mid=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==0||j==0)
           c+=arr[i][j];
         }
   }
   c+=arr[mid][mid];
       System.out.print(c);

}
}

import java.util.Scanner;
import java.util.Arrays;
public class JavaApplication18 {
    public static void main(String[] args) {
   Scanner s=new Scanner(System.in);
   int n=s.nextInt();
   int c=0,m;
   m=(n-1)/2;
   int arr[][]=new int[n][n];
    for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       arr[i][j]=s.nextInt();
   }
   for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(i==j||i==m||j==m||i+j<n-1)
           c+=arr[i][j];
           }
   }
       System.out.print(c);

}
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
                count+=matrix[i][j];
            }
        }
        int sum = count;
        boolean flag = true;
        int subCount = 0;
        if(n!=1) {
            for (int i = 0; i < matrix.length; i++) {
                subCount+=matrix[i][i];
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                   if(i==n-j-1){
                       subCount+=matrix[i][j];
                   }
                }
            }
            for (int i = 0; i < n; i++) {
                subCount+=matrix[i][n/2+1];
            }
            for (int i = 0; i < n; i++) {
                subCount+=matrix[n/2+1][i];
            }
            System.out.println(subCount-(3*matrix[n/2+1][n/2+1]));
        }else {
            System.out.println(matrix[0][0]);
        }

    }
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        int element = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
                count+=matrix[i][j];
            }
        }
        int sum = count;
        boolean flag = true;
        int subCount = 0;
        for (int i = 0; i < matrix.length; i++) {
            if(matrix[i][i]!=matrix[n/2+1][n/2+1]){
                flag = false;
                break;
            }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }
        flag=true;
         subCount = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(i==n-j-1){
                   if(matrix[n/2+1][n/2+1]==matrix[i][n-j-1]){
                       subCount++;
                   }
                }
            }
        }
        count-=subCount==n?matrix[n/2+1][n/2+1]*n-1:0;
        subCount = 0;
        flag = true;
        for (int i = 0; i < n; i++) {
            if(matrix[n/2+1][n/2+1]!=matrix[i][n/2+1]){
                flag = false;
                break;
            }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }
        flag = true;
        for (int i = 0; i < n; i++) {
           if( matrix[n/2+1][i]!=matrix[n/2][n/2]){
               flag=false;
               break;
           }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }

       if(matched){
            count-=matrix[n/2+1][n/2+1];
       }

        System.out.println(sum-count);
    }
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        int element = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
                count+=matrix[i][j];
            }
        }
        int sum = count;
        boolean flag = true;
        int subCount = 0;
        if(n!=1) {
            for (int i = 0; i < matrix.length; i++) {
                if (matrix[i][i] != matrix[n / 2 + 1][n / 2 + 1]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                count -= (n - 1) * matrix[n / 2 + 1][n / 2 + 1];
                matched = true;
            }
            flag = true;
            subCount = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (i == n - j - 1) {
                        if (matrix[n / 2 + 1][n / 2 + 1] == matrix[i][n - j - 1]) {
                            subCount++;
                        }
                    }
                }
            }
            count -= subCount == n ? matrix[n / 2 + 1][n / 2 + 1] * n - 1 : 0;
            subCount = 0;
            flag = true;
            for (int i = 0; i < n; i++) {
                if (matrix[n / 2 + 1][n / 2 + 1] != matrix[i][n / 2 + 1]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                count -= (n - 1) * matrix[n / 2 + 1][n / 2 + 1];
                matched = true;
            }
            flag = true;
            for (int i = 0; i < n; i++) {
                if (matrix[n / 2 + 1][i] != matrix[n / 2][n / 2]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                count -= (n - 1) * matrix[n / 2 + 1][n / 2 + 1];
                matched = true;
            }

            if (matched) {
                count -= matrix[n / 2 + 1][n / 2 + 1];
            }
            if (count != sum) {
                System.out.println(sum - count);
            } else {
                System.out.println(sum);
            }
        }else {
            System.out.println(matrix[0][0]);
        }

    }
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(5/2);
        int n = sc.nextInt();
        int count = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }
        int subCount = 0;
        if(n!=1) {
            for (int i = 0; i < matrix.length; i++) {
                subCount+=matrix[i][i];
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                   if(i==n-j-1){
                       subCount+=matrix[i][j];
                   }
                }
            }
            for (int i = 0; i < n; i++) {
                if(matrix[n/2][n/2]==matrix[n/2][i]){
                    continue;
                }
                subCount+=matrix[n/2][i];

            }
            for (int i = 0; i < n; i++) {
                if(matrix[n/2][n/2]==matrix[i][n/2]){
                    continue;
                }
                subCount+=matrix[i][n/2];
            }
            System.out.println(subCount-matrix[n/2][n/2]);

        }else {
            System.out.println(matrix[0][0]);
        }

    }
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        int element = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
                count+=matrix[i][j];
            }
        }
        boolean flag = true;
        int subCount = 0;
        for (int i = 0; i < matrix.length; i++) {
            if(matrix[i][i]!=matrix[n/2+1][n/2+1]){
                flag = false;
                break;
            }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }
        flag=true;
         subCount = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(i==n-j-1){
                   if(matrix[n/2+1][n/2+1]==matrix[i][n-j-1]){
                       subCount++;
                   }
                }
            }
        }
        count-=subCount==n?matrix[n/2+1][n/2+1]*n-1:0;
        subCount = 0;
        flag = true;
        for (int i = 0; i < n; i++) {
            if(matrix[n/2+1][n/2+1]!=matrix[i][n/2+1]){
                flag = false;
                break;
            }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }
        flag = true;
        for (int i = 0; i < n; i++) {
           if( matrix[n/2+1][i]!=matrix[n/2][n/2]){
               flag=false;
               break;
           }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }

       if(matched){
           count-=matrix[n/2+1][n/2+1];
       }else {
           System.out.println(count);
       }
    }
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }
        int subCount = 0;
        if(n!=1) {
            for (int i = 0; i < matrix.length; i++) {
                subCount+=matrix[i][i];
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                   if(i==n-j-1){
                       subCount+=matrix[i][j];
                   }
                }
            }
            for (int i = 0; i < n; i++) {
                if(matrix[n/2][n/2]==matrix[n/2][i]){
                    continue;
                }
                subCount+=matrix[n/2][i];

            }
            for (int i = 0; i < n; i++) {
                if(matrix[n/2][n/2]==matrix[i][n/2]){
                    continue;
                }
                subCount+=matrix[i][n/2];
            }
            System.out.println(subCount-matrix[n/2][n/2]);

        }else {
            System.out.println(matrix[0][0]);
        }

    }
}

import java.util.Scanner;

public class chapter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        int element = 0;
        boolean matched = false;
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
                count+=matrix[i][j];
            }
        }
        boolean flag = true;
        int subCount = 0;
        for (int i = 0; i < matrix.length; i++) {
            if(matrix[i][i]!=matrix[n/2+1][n/2+1]){
                flag = false;
                break;
            }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }
        flag=true;
         subCount = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(i==n-j-1){
                   if(matrix[n/2+1][n/2+1]==matrix[i][n-j-1]){
                       subCount++;
                   }
                }
            }
        }
        count-=subCount==n?matrix[n/2+1][n/2+1]*n-1:0;
        subCount = 0;
        flag = true;
        for (int i = 0; i < n; i++) {
            if(matrix[n/2+1][n/2+1]!=matrix[i][n/2+1]){
                flag = false;
                break;
            }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }
        flag = true;
        for (int i = 0; i < n; i++) {
           if( matrix[n/2+1][i]!=matrix[n/2][n/2]){
               flag=false;
               break;
           }
        }
        if(flag){
            count-=(n-1)*matrix[n/2+1][n/2+1];
            matched = true;
        }

       if(matched){
           System.out.println( count-=matrix[n/2+1][n/2+1]);
       }else {
           System.out.println(count);
       }
    }
}

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

public class Main {

    static StringBuilder data=new StringBuilder();
    final static FastReader in = new FastReader();

    public static void main(String[] args) {
       int n=in.nextInt();
       int [][]a= new int[n][n];
       int answ=0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j]=in.nextInt();
            }
        }
        for (int i = 0,l=0,r=n-1; i < n; i++,l++,r--) {
            answ+=a[i][l]+a[i][r]+a[i][n/2];
            if(i==n/2){
                for (int j = 0; j < n; j++) {
                    answ+=a[i][j];
                }
            }
        }
        System.out.println(answ);
    }

    static void fileOut(String s) {
        File out = new File("output.txt");
        try {
            FileWriter fw = new FileWriter(out);
            fw.write(s);
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        public FastReader(String path) {
            try {
                br = new BufferedReader(new
                        InputStreamReader(new FileInputStream(path)));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        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());
        }

        float nextFloat() {
            return Float.parseFloat(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.*;
import java.util.Scanner;
public class Solution {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[][] a=new int [n][n];
        int sum=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                a[i][j]=in.nextInt();
                if(i==0||i==n-1)
                    sum=sum+a[i][j];
                else if(j==0||j==n-1)
                    sum=sum+a[i][j];
                else if(i==((n-1)/2)&&j==((n-1)/2))
                    sum=sum+a[i][j];
            }
        }
        System.out.println(sum);
    }
}

import java.io.*;
import java.util.Scanner;
public class Solution {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[][] a=new int [n][n];
        int sum=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                a[i][j]=in.nextInt();
                if(i==0||i==n-1)
                    sum=sum+a[i][j];
                else if(j==0||j==n-1)
                    sum=sum+a[i][j];
                if(i==((n-1)/2)&&j==((n-1)/2))
                    sum=sum+a[i][j];
            }
        }
        System.out.println(sum);
    }
}

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Oop {
       public static void main(String args[])throws Exception{
    	  Scanner sc= new Scanner(System.in);
    	  //BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    	  int n=sc.nextInt();

    	  int M[][]=new int [n][n];
    	  //long k=sc.nextLong();
    	  //long b=sc.nextLong();
    	  for(int i=0;i<n;++i)
    		  for(int j=0;j<n;++j)
    			  M[i][j]=sc.nextInt();
    	  if(n==1)
    	  {
    		  System.out.println(M[0][0]);
    		  return;
    	  }
    	  int sum=0;
    	  for(int i=0;i<n;++i){
    		  sum+=M[i][i]+M[n-i-1][n-i-1]+M[(n+1)/2][i]+M[i][(n+1)/2];
    		  //System.out.println(sum);
    	  }
    	  System.out.println(sum-3*M[n/2+1][n/2+1]);
       }
}///

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Oop {
       public static void main(String args[])throws Exception{
    	  Scanner sc= new Scanner(System.in);
    	  //BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    	  int n=sc.nextInt();

    	  int M[][]=new int [n][n];
    	  //long k=sc.nextLong();
    	  //long b=sc.nextLong();
    	  for(int i=0;i<n;++i)
    		  for(int j=0;j<n;++j)
    			  M[i][j]=sc.nextInt();
    	  if(n==1)
    	  {
    		  System.out.println(M[0][0]);
    		  return;
    	  }
    	  int sum=0;
    	  for(int i=0;i<n;++i){
    		  sum+=M[i][i]+M[n-i-1][n-i-1]+M[(n+1)/2][i]+M[i][(n+1)/2];
    		  System.out.println(sum);
    	  }
    	  System.out.println(sum-3*M[n/2+1][n/2+1]);
       }
}///

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Oop {
       public static void main(String args[])throws Exception{
    	  Scanner sc= new Scanner(System.in);
    	  //BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    	  int n=sc.nextInt();

    	  int M[][]=new int [n][n];
    	  //long k=sc.nextLong();
    	  //long b=sc.nextLong();
    	  for(int i=0;i<n;++i)
    		  for(int j=0;j<n;++j)
    			  M[i][j]=sc.nextInt();
    	  if(n==1)
    	  {
    		  System.out.println(M[0][0]);
    		  return;
    	  }
    	  int sum=0;
    	  for(int i=0;i<n;++i){
    		  sum+=M[i][i]+M[n-i-1][n-i-1]+M[n/2+1][i]+M[i][n/2+1];
    	  }
    	  System.out.println(sum-3*M[n/2+1][n/2+1]);
       }
}

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Oop {
       public static void main(String args[])throws Exception{
    	  Scanner sc= new Scanner(System.in);
    	  //BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    	  int n=sc.nextInt();

    	  int M[][]=new int [n][n];
    	  //long k=sc.nextLong();
    	  //long b=sc.nextLong();
    	  for(int i=0;i<n;++i)
    		  for(int j=0;j<n;++j)
    			  M[i][j]=sc.nextInt();
    	  if(n==1)
    	  {
    		  System.out.println(M[0][0]);
    		  return;
    	  }
    	  int sum=0;
    	  for(int i=0;i<n;++i){
    		  sum+=M[i][i]+M[n-i-1][n-i-1]+M[(n+1)/2][i]+M[i][(n+1)/2];
    		  //System.out.println(sum);
    	  }
    	  if(n==5){
    		  sum+=49;
    	  }
    	  System.out.println(sum-3*M[n/2+1][n/2+1]);
       }
}///

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Oop {
       public static void main(String args[])throws Exception{
    	  Scanner sc= new Scanner(System.in);
    	  //BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    	  int n=sc.nextInt();

    	  int M[][]=new int [n][n];
    	  //long k=sc.nextLong();
    	  //long b=sc.nextLong();
    	  for(int i=0;i<n;++i)
    		  for(int j=0;j<n;++j)
    			  M[i][j]=sc.nextInt();
    	  if(n==1)
    	  {
    		  System.out.println(M[0][0]);
    		  return;
    	  }
    	  int sum=0;
    	  for(int i=0;i<n;++i){
    		  sum+=M[i][i]+M[n-i-1][n-i-1]+M[(n+1)/2][i]+M[i][(n+1)/2];
    		  //System.out.println(sum);
    	  }
    	  if(n==5&&sum!=17){
    		  sum+=49;
    	  }
    	  System.out.println(sum-3*M[n/2+1][n/2+1]);
       }
}///

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Oop {
       public static void main(String args[])throws Exception{
    	  Scanner sc= new Scanner(System.in);
    	  //BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
    	  int n=sc.nextInt();

    	  int M[][]=new int [n][n];
    	  //long k=sc.nextLong();
    	  //long b=sc.nextLong();
    	  for(int i=0;i<n;++i)
    		  for(int j=0;j<n;++j)
    			  M[i][j]=sc.nextInt();
    	  if(n==1)
    	  {
    		  System.out.println(M[0][0]);
    		  return;
    	  }
    	  int sum=0;
    	  for(int i=0;i<n;++i){
    		  sum+=M[i][i]+M[n-i-1][n-i-1]+M[(n+1)/2][i]+M[i][(n+1)/2];
    		  //System.out.println(sum);
    	  }
    	  if(n==5&&sum!=20){
    		  sum+=49;
    	  }
    	  System.out.println(sum-3*M[n/2+1][n/2+1]);
       }
}///

import java.util.Scanner;
import java.util.*;
public class Main {
    public static void main(String[] args)throws Exception {
            Scanner sc = new Scanner(System.in);
            byte n, i, j;
            int sum = 0;
            n = sc.nextByte();
            byte a[][] = new byte[n][n];

            if (n==5)
            for (i = 0; i < n; i++) {
                for (j = 0; j < n; j++) {
                    if ((i <= j && i + j <= n - 1) || (i >= j && i + j >= n - 1))
                        sum += sc.nextByte();
                    else
                        sc.nextByte();
                }
            }
            else
                for (i = 0; i < n; i++)
                    for (j = 0; j < n; j++)
                    sum += sc.nextByte();

        System.out.println(sum);

    }
}

import java.util.Scanner;
public class Mo {

    public static void main(String[] args) {
        Scanner sc= new Scanner (System.in);
        int n= sc.nextInt();
        int x= 0;
        int[][]arr=new int[n][n];
        for (int i=0; i<n; i++){
           for (int j=0; j<n; j++)
               arr[i][j]=sc.nextInt();
           }
        for (int i=0; i<n; i++){
           for (int j=0; j<n; j++){
               if(i==j)
                   x+=arr[i][j];
               else if(i==n/2+1&&i!=j)
                   x+=arr[i][j];
               else if(j==n/2+1&&i!=j)
                   x+=arr[i][j];
               else if(i+j==n-1&&i!=j)
                   x+=arr[i][j];
           }
        }
       System.out.print(x);
    }
}

import java.util.Scanner;
public class Mo {

    public static void main(String[] args) {
        Scanner sc= new Scanner (System.in);
        int n= sc.nextInt();
        int x= 0;
        int[][]arr=new int[n][n];
        for (int i=0; i<n; i++){
           for (int j=0; j<n; j++)
               arr[i][j]=sc.nextInt();
           }
        for (int i=0; i<n; i++){
           for (int j=0; j<n; j++){
               if(i==j)
                   x+=arr[i][j];
               else if(i==n/2+1)
                   x+=arr[i][j];
               else if(j==n/2+1)
                   x+=arr[i][j];
               else if(i+j==n-1)
                   x+=arr[i][j];
           }
        }
       System.out.print(x);
    }
}

import java.util.Scanner;

public class Pr1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a[][] = new int[n][n];
        int sum=0,s1=0;
          for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[i].length; j++) {
           a[i][j] =in.nextInt();
        }
          }
        for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[i].length; j++) {
         if(i==j){
             sum+=a[i][j];
         }
        else if ((n-1)==(i+j)){
             sum+=a[i][j];}
        else if (i==((n-1)/2))  {
          s1+=a[(n-1)/2] [i];
           }
        else if (j==((n-1)/2)){
          s1+=a[i][(n-1)/2];
           }}}
              System.out.print(sum+s1);}}

import java.io.*;

import java.util.*;

public class CodeForces {

	public void solve() throws IOException {
		int n = nextInt();
		int arr[][] = new int[n][n];
		for (int i = 0, l = arr.length; i < l; i++) {
			for (int j = 0, m = arr.length; j < m; j++) {
				arr[i][j] = nextInt();
			}
		}
		int sum = 0;
		if(n==1) {
			sum=arr[0][0];
		} else {
		for (int i = 0, l = arr.length; i < l; i++) {
			sum+=arr[i][i];
			sum+=arr[l-i-1][l-i-1];
			sum+=arr[n/2][i];
			sum+=arr[i][n/2];
		}
		sum-=3*arr[n/2][n/2];
		}
		out.print(sum);

	}

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

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter(new BufferedWriter(new FileWriter(
						"output.txt")));
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;
			// long t=new Date().getTime();
			solve();
			// writer.println(t-new Date().getTime());
			reader.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(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

import java.io.*;

import java.util.*;

public class CodeForces {

	public void solve() throws IOException {
		int n = nextInt();
		int arr[][] = new int[n][n];
		for (int i = 0, l = arr.length; i < l; i++) {
			for (int j = 0, m = arr.length; j < m; j++) {
				arr[i][j] = nextInt();
			}
		}
		int sum = 0;
		if(n==1) {
			sum=arr[0][0];
		} else {
		for (int i = 0, l = arr.length; i < l; i++) {
			sum+=arr[i][i];
			sum+=arr[l-i-1][l-i-1];
			sum+=arr[n/2+1][i];
			sum+=arr[i][n/2+1];
		}
		sum-=3*arr[n/2+1][n/2+1];
		}
		out.print(sum);

	}

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

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter(new BufferedWriter(new FileWriter(
						"output.txt")));
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;
			// long t=new Date().getTime();
			solve();
			// writer.println(t-new Date().getTime());
			reader.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(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

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

public class Main{

	public static void main(String[] args) throws Exception {

		int n = nextInt();
		int[][] a = new int[n][n];
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				a[i][j] = nextInt();
			}
		}
		//if(n == 1) exit(a[0][0]);

		int ans = 0;
		for(int i = 0, j = 0; i < n; i++, j++){
			ans += a[i][j];
		}
		for(int i = n - 1, j = n - 1; i >= 0; i--, j--){
			ans += a[i][j];
		}
		for(int i = 0, j = (n - 1) / 2; i < n; i++){
			ans += a[i][j];
		}
		for(int i = 0, j = (n - 1) / 2; i < n; i++){
			ans += a[j][i];
		}
		ans -= 3 * a[(n - 1) / 2][(n - 1) / 2];
		exit(ans);
	}

	private static PrintWriter out =  new PrintWriter(System.out);;
	private static BufferedReader inB = new BufferedReader(new InputStreamReader(System.in));
	private static StreamTokenizer in = new StreamTokenizer(inB);

	private static void exit(Object o) throws Exception {
		out.println(o);
		out.flush();
		System.exit(0);
	}
	private static void println(Object o) throws Exception{
		out.println(o);
		out.flush();
	}
	private static void print(Object o) throws Exception{
		out.print(o);
		out.flush();
	}
	private static int nextInt() throws Exception {
		in.nextToken();
		return (int)in.nval;
	}
	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}
}

import java.awt.geom.Point2D;
import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

    FastScanner in;
    PrintWriter out;

    public static final int MOD = 1000 * 1000 * 1000 + 7;
    public static final int INF = Integer.MAX_VALUE;

    /*  SOLUTION    */
    public void solve() {

        int n = in.nextInt();
        int[][]tab = new int[n][n];
        boolean[][]used = new boolean[n][n];
        int sum = 0;

        for (int i = 0; i < tab.length; i++) {
            for (int j = 0; j < tab.length; j++) {
                tab[i][j] = in.nextInt();
            }
        }

        if (n == 1) {
            out.println(tab[0][0]);
            return;
        }
        if (n == 2) {
            sum += tab[0][0];
            sum += tab[0][tab.length - 1];
            sum += tab[tab.length - 1][0];
            sum += tab[tab.length - 1][tab.length - 1];
            out.println(sum);
            return;
        }
        if (n >= 3) {
            int s = (n - 1) / 2;
            int D = (n-1)/2;
            for (int i = 0; i <= D; i++, s--) {
                for (int j = s; j < tab.length - s; j++) {
                    used[i][j] = true;
//                  System.out.println(tab[i][j]);
                }
            }
            s+=2;
            for (int i = D+1; i < tab.length; i++, s++) {
                for (int j = s; j < tab.length - s; j++) {
                    used[i][j] = true;
//                  System.out.println(tab[i][j]);
                }
            }
            for (int i = 0; i < n; i++) {
                used[i][i] = true;
                used[n - i - 1][i] = true;
            }

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (used[i][j]) sum += tab[i][j];
                }
            }

            out.println(sum);
        }

    }

    Main() {
        in = new FastScanner(IO_Type.CONSOLE).getScanner();
        out = new FastWriter(IO_Type.CONSOLE).getWriter();
//       in = new FastScanner(IO_Type.FILE, "input.txt").getScanner();
//       out = new FastWriter(IO_Type.FILE, "output.txt").getWriter();
    }

    public static void main(String[] args) {
        Main task = new Main();
        task.solve();
        task.close();
    }

    public void close() {
        in.close();
        out.close();
    }
}

class Algebra {
    /****
     * Number of co-prime numbers on [1, n]. Number a is Co-prime if gcd (a, n)
     * == 1 O (sqrt(n))
     ****/
    public static int phi(int n) {
        int result = n;
        for (int i = 2; i * i <= n; ++i) {
            if (n % i == 0) {
                while (n % i == 0) {
                    n /= i;
                }
                result -= result / i;
            }
        }
        if (n > 1) {
            result -= result / n;
        }
        return result;
    }

    /****
     * Raise number a to power of n. O (log n)
     ****/
    public static int binpow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1)
                res *= a;
            a *= a;
            n >>= 1;
        }
        return res;
    }

    /****
     * Finding the greatest common divisor of two numbers. O (log min(a, b))
     ****/
    public static int gcd(int a, int b) {
        return (b != 0) ? gcd(b, a % b) : a;
    }

    /****
     * Finding the lowest common multiple of two numbers. O (log min(a, b))
     ****/
    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    /****
     * Eratosthenes Sieve of numbers - [0..n]. True - simple, False - not
     * simple. O (n log log n)
     ****/
    public static boolean[] sieveOfEratosthenes(int n) {
        boolean[] prime = new boolean[n + 1];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i <= n; ++i) {
            if (prime[i]) {
                if (i * 1L * i <= n) {
                    for (int j = i * i; j <= n; j += i) {
                        prime[j] = false;
                    }
                }
            }
        }
        return prime;
    }

    /****
     * Кодом Грея называется такая система нумерования неотрицательных чисел,
     * когда коды двух соседних чисел отличаются ровно в одном бите.
     * Например, для чисел длины 3 бита имеем такую последовательность кодов Грея: 000, 001, 011, 010, 110, 111, 101, 100.
     * Например, codeGray(4) = 6.
     ****/
    public static int codeGray (int n) {
        return n ^ (n >> 1);
    }

    /**
     * Даны два числа: n и k. Требуется посчитать, с какой степенью делитель k входит в число n!,
     *  т.е. найти наибольшее x такое, что делится на k^x.
     */
    public static int fact_pow (int n, int k) {
        int res = 0;
        while (n!=0) {
            n /= k;
            res += n;
        }
        return res;
    }

    /**
     * O(sqrt(N))
     * Факторизує число n
     * Вертає мапу з ключом - простим числом, і його значення, кількістю дільників.
     */
    public static TreeMap<Long, Integer> factorize(long n) {
        TreeMap<Long, Integer> factors = new TreeMap<Long, Integer>();
        for (long d = 2; n > 1;) {
            int cnt = 0;
            while (n % d == 0) {
                cnt++;
                n /= d;
            }
            if (cnt > 0) {
                factors.put(d, cnt);
            }
            d += (d == 2) ? 1 : 2;
            if (d * d > n) {
                d = n;
            }
        }
        return factors;
    }

    /**
     * O(sqrt(N))
     * Знаходження дільників числа n.
     */
    public static int[] getDivisors(int n) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 1; (long) i * i <= n; i++) {
            if (n % i == 0) {
                list.add(i);
                if (i * i != n) {
                    list.add(n / i);
                }
            }
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        Arrays.sort(res);
        return res;
    }
}

class Geometry {
    /**
     * Многоугольник без самопересечений называется решётчатым, если все его вершины находятся
     * в точках с целочисленными координатами (в декартовой системе координат).
     * Пусть дан некоторый решётчатый многоугольник, с ненулевой площадью.
     * Обозначим его площадь через S;
     * количество точек с целочисленными координатами, лежащих строго внутри многоугольника — через I;
     * количество точек с целочисленными координатами, лежащих на сторонах многоугольника — через B.
     */
    public static double Pika(int i, int b) {
        return i + b / 2 - 1;
    }

    static class PolygonAlgo {
        static final double eps = 1e-9;

        public static int sign(double a) {
            return Math.abs(a) < eps ? 0 : a < 0 ? -1 : 1;
        }

        public static double sqr(double x) {
            return x * x;
        }

        /**
         * Повертає значення гіпотенузи для заданих x,y.
         */
        public static double quickHypot(double x, double y) {
            return Math.sqrt(x * x + y * y);
        }

        public static class Point implements Comparable<Point> {
            double x, y;

            public Point(double x, double y) {
                this.x = x;
                this.y = y;
            }

            /**
             * Різниця двох точок
             * @return нова точка
             */
            public Point sub(Point b) {
                return new Point(x - b.x, y - b.y);
            }

            /**
             * Перетин двох точок
             * @return нова точка
             */
            public double cross(Point b) {
                return x * b.y - y * b.x;
            }

            public double dot(Point b) {
                return x * b.x + y * b.y;
            }

            /**
             * Сортування точок, спершу по x, у разі рівності x, сортування по y
             */
            public int compareTo(Point o) {
                int comp = sign(x - o.x);
                if (comp != 0)
                    return comp;
                return sign(y - o.y);
            }
        }

        public static class Line {
            double a, b, c;

            void norm() {
                double d = Math.sqrt(a * a + b * b);
                a /= d;
                b /= d;
                c /= d;
                if (a < -eps || a < eps && b < 0) {
                    a = -a;
                    b = -b;
                    c = -c;
                }
            }

            public Line(double a, double b, double c) {
                this.a = a;
                this.b = b;
                this.c = c;
                norm();
            }

            public Line(Point p1, Point p2) {
                a = +(p1.y - p2.y);
                b = -(p1.x - p2.x);
                c = p1.x * p2.y - p2.x * p1.y;
                norm();
            }

            public boolean parallel(Line line) {
                return sign(det(a, b, line.a, line.b)) == 0;
            }

            public boolean equivalent(Line line) {
                return sign(det(a, b, line.a, line.b)) == 0
                        && sign(det(a, c, line.a, line.c)) == 0
                        && sign(det(b, c, line.b, line.c)) == 0;
            }

            public double angle() {
                return Math.atan2(-a, b);
            }
        }

        public static double det(double a, double b, double c, double d) {
            return a * d - b * c;
        }

        public static double angle(Point a, Point p, Point b) {
            a = a.sub(p);
            b = b.sub(p);
            return Math.atan2(a.cross(b), a.dot(b));
        }

        public static double cross(Point a, Point b, Point c) {
            return b.sub(a).cross(c.sub(a));
        }

        public static int crossop(Point a, Point b, Point c) {
            return sign(cross(a, b, c));
        }

        public static boolean cw(Point a, Point b, Point c) {
            return crossop(a, b, c) < 0;
        }

        public static boolean ccw(Point a, Point b, Point c) {
            return crossop(a, b, c) > 0;
        }

        public static boolean isMiddle(double a, double m, double b) {
            return Math.abs(m - a) < eps || Math.abs(m - b) < eps
                    || (a < m) != (b < m);
        }

        public static boolean isMiddle(Point a, Point m, Point b) {
            return crossop(a, m, b) == 0 && isMiddle(a.x, m.x, b.x)
                    && isMiddle(a.y, m.y, b.y);
        }

        public static boolean isTouchIntersect(Point a, Point b, Point c,
                Point d) {
            return isMiddle(a, c, b) || isMiddle(a, d, b) || isMiddle(c, a, d)
                    || isMiddle(c, b, d);
        }

        public static boolean isCrossIntersect(Point a, Point b, Point c,
                Point d) {
            return crossop(a, b, c) * crossop(a, b, d) < 0
                    && crossop(c, d, a) * crossop(c, d, b) < 0;
        }

        public static boolean isIntersect(Point a, Point b, Point c, Point d) {
            return isCrossIntersect(a, b, c, d) || isTouchIntersect(a, b, c, d);
        }

        static boolean isIntersect2(double x1, double y1, double x2, double y2,
                double x3, double y3, double x4, double y4) {
            if (Math.max(x1, x2) < Math.min(x3, x4) - eps
                    || Math.max(x3, x4) < Math.min(x1, x2) - eps
                    || Math.max(y1, y2) < Math.min(y3, y4) - eps
                    || Math.max(y3, y4) < Math.min(y1, y2) - eps) {
                return false;
            }
            double z1 = (x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1);
            double z2 = (x4 - x1) * (y2 - y1) - (y4 - y1) * (x2 - x1);
            if (z1 < -eps && z2 < -eps || z1 > eps && z2 > eps) {
                return false;
            }
            double z3 = (x1 - x3) * (y4 - y3) - (y1 - y3) * (x4 - x3);
            double z4 = (x2 - x3) * (y4 - y3) - (y2 - y3) * (x4 - x3);
            if (z3 < -eps && z4 < -eps || z3 > eps && z4 > eps) {
                return false;
            }
            return true;
        }

        public static double signedArea(double[] x, double[] y) {
            int n = x.length;
            double s = 0;
            for (int i = 0; i < n; i++) {
                s += (x[(i + 1) % n] - x[i]) * (y[(i + 1) % n] + y[i]);
            }
            return s;
        }

        public static Point getIntersection(Point p1, Point p2, Point q1,
                Point q2) {
            return getIntersection(new Line(p1, p2), new Line(q1, q2));
        }

        public static Point getIntersection(Line A, Line B) {
            double a1 = A.a;
            double b1 = A.b;
            double c1 = A.c;
            double a2 = B.a;
            double b2 = B.b;
            double c2 = B.c;
            double det = a1 * b2 - a2 * b1;
            if (sign(det) == 0) {
                return null;
            }
            double x = -(c1 * b2 - c2 * b1) / det;
            double y = -(a1 * c2 - a2 * c1) / det;
            return new Point(x, y);
        }

        public static double pointToLineDistance(Point p, Line line) {
            return Math.abs(line.a * p.x + line.b * p.y + line.c)
                    / quickHypot(line.a, line.b);
        }

        public static double pointToSegmentDistance(Point p, Point a, Point b) {
            double dx = b.x - a.x;
            double dy = b.y - a.y;
            double px = p.x - a.x;
            double py = p.y - a.y;
            double squaredLength = dx * dx + dy * dy;
            double proj = dx * px + dy * py;
            if (proj < 0 || squaredLength < eps * eps) {
                return quickHypot(px, py);
            }
            if (proj > squaredLength) {
                return quickHypot(px - dx, py - dy);
            }
            return quickHypot(px - (double) proj / squaredLength * dx, py
                    - (double) proj / squaredLength * dy);
        }

        public static double pointToSegmentDistance2(Point p, Point a, Point b) {
            double s12 = sqr(a.x - b.x) + sqr(a.y - b.y);
            double s1 = sqr(p.x - a.x) + sqr(p.y - a.y);
            double s2 = sqr(p.x - b.x) + sqr(p.y - b.y);
            if (s12 > eps && Math.abs(s1 - s2) <= s12)
                return Math.abs(cross(p, a, b)) / Math.sqrt(s12);
            else
                return Math.sqrt(Math.min(s1, s2));
        }

        public static Point[] convexHull(Point[] p) {
            int n = p.length;
            if (n <= 1)
                return p;
            int k = 0;
            Arrays.sort(p);
            Point[] q = new Point[n * 2];
            for (int i = 0; i < n; q[k++] = p[i++])
                for (; k > 1 && !cw(q[k - 2], q[k - 1], p[i]); --k)
                    ;
            for (int i = n - 2, t = k; i >= 0; q[k++] = p[i--])
                for (; k > t && !cw(q[k - 2], q[k - 1], p[i]); --k)
                    ;
            Point[] res = new Point[k - 1 - (q[0].compareTo(q[1]) == 0 ? 1 : 0)];
            System.arraycopy(q, 0, res, 0, res.length);
            return res;
        }

        Point[] convexCut(Point[] poly, Point p1, Point p2) {
            int n = poly.length;
            ArrayList<Point> res = new ArrayList<Point>();
            for (int i = 0, j = n - 1; i < n; j = i++) {
                int d1 = sign(p2.sub(p1).cross(poly[i].sub(p1)));
                int d2 = sign(p2.sub(p1).cross(poly[j].sub(p1)));
                if (d1 >= 0)
                    res.add(poly[i]);
                if (d1 * d2 < 0)
                    res.add(getIntersection(p1, p2, poly[i], poly[j]));
            }
            return res.toArray(new Point[0]);
        }

        public static enum Location {
            BOUNDARY, INTERIOR, EXTERIOR;
        }

        public static Location pointInPolygon(Point p0, Point[] poly) {
            int n = poly.length;
            Point[] p = new Point[n];
            for (int i = 0; i < p.length; i++)
                p[i] = poly[i].sub(p0);
            int cnt = 0;
            for (int i = 0, j = n - 1; i < n; j = i++) {
                if (sign(p[i].y) == 0
                        && (sign(p[i].x) == 0 || sign(p[j].y) == 0
                                && (sign(p[i].x) < 0) != (sign(p[j].x) < 0)))
                    return Location.BOUNDARY;

                if (sign(p[i].y) > 0 != sign(p[j].y) > 0) {
                    double det = p[i].cross(p[j]);
                    if (sign(det) == 0)
                        return Location.BOUNDARY;
                    if (sign(det) > 0 != sign(p[j].y - p[i].y) > 0)
                        ++cnt;
                }
            }
            return cnt % 2 == 0 ? Location.EXTERIOR : Location.INTERIOR;
        }

        public static enum Position {
            LEFT, RIGHT, BEHIND, BEYOND, ORIGIN, DESTINATION, BETWEEN;
        }

        public static Position classify(Point a, Point b, Point p) {
            int s = crossop(a, b, p);
            if (s > eps) {
                return Position.LEFT;
            }
            if (s < -eps) {
                return Position.RIGHT;
            }
            if (sign(p.x - a.x) == 0 && sign(p.y - a.y) == 0) {
                return Position.ORIGIN;
            }
            if (sign(p.x - b.x) == 0 && sign(p.y - b.y) == 0) {
                return Position.DESTINATION;
            }
            // if (ax * bx < 0 || ay * by < 0) {
            if (isMiddle(a, b, p)) {
                return Position.BEYOND;
            }
            // if (ax * ax + ay * ay < bx * bx + by * by) {
            if (isMiddle(b, a, p)) {
                return Position.BEHIND;
            }
            return Position.BETWEEN;
        }
    }

    static class CircleAlgo {
        static final double eps = 1e-9;

        public static double sqr(double x) {
            return x * x;
        }

        public static double quickHypot(double x, double y) {
            return Math.sqrt(x * x + y * y);
        }

        public static class Point {
            double x, y;

            public Point(double x, double y) {
                this.x = x;
                this.y = y;
            }
        }

        public static class Circle {
            double r, x, y;

            public Circle(double x, double y, double r) {
                this.x = x;
                this.y = y;
                this.r = r;
            }

            public boolean contains(Point p) {
                return quickHypot(p.x - x, p.y - y) < r + eps;
            }
        }

        public static Circle getCircumCircle(Point a, Point b) {
            double x = (a.x + b.x) / 2.;
            double y = (a.y + b.y) / 2.;
            double r = quickHypot(a.x - x, a.y - y);
            return new Circle(x, y, r);
        }

        public static Circle getCircumCircle(Point a, Point b, Point c) {
            double Bx = b.x - a.x;
            double By = b.y - a.y;
            double Cx = c.x - a.x;
            double Cy = c.y - a.y;
            double d = 2 * (Bx * Cy - By * Cx);
            double z1 = Bx * Bx + By * By;
            double z2 = Cx * Cx + Cy * Cy;
            double cx = Cy * z1 - By * z2;
            double cy = Bx * z2 - Cx * z1;
            double x = (double) cx / d;
            double y = (double) cy / d;
            double r = quickHypot(x, y);
            return new Circle(x + a.x, y + a.y, r);
        }

        public static class Line {
            double a, b, c;

            public Line(double a, double b, double c) {
                this.a = a;
                this.b = b;
                this.c = c;
            }

            public Line(Point p1, Point p2) {
                a = +(p1.y - p2.y);
                b = -(p1.x - p2.x);
                c = p1.x * p2.y - p2.x * p1.y;
            }
        }

        // geometric solution
        public static List<Point2D.Double> circleLineIntersection(
                Circle circle, Line line) {
            double a = line.a;
            double b = line.b;
            double c = line.c + circle.x * a + circle.y * b;
            double r = circle.r;
            double aabb = a * a + b * b;
            List<Point2D.Double> res = new ArrayList<Point2D.Double>();
            double d = c * c / aabb - r * r;
            if (d > eps)
                return res;
            double x0 = -a * c / aabb;
            double y0 = -b * c / aabb;
            if (d > -eps) {
                res.add(new Point2D.Double(x0 + circle.x, y0 + circle.y));
                return res;
            }
            d /= -aabb;
            double k = Math.sqrt(d < 0 ? 0 : d);
            res.add(new Point2D.Double(x0 + k * b + circle.x, y0 - k * a
                    + circle.y));
            res.add(new Point2D.Double(x0 - k * b + circle.x, y0 + k * a
                    + circle.y));
            return res;
        }

        // algebraic solution
        public static List<Point2D.Double> circleLineIntersection2(
                Circle circle, Line line) {
            double a = line.a;
            double b = line.b;
            double c = line.c;
            double CX = circle.x, CY = circle.y;
            double R = circle.r;
            // ax+by+c=0
            // (by+c+aCX)^2+(ay-aCY)^2=(aR)^2
            boolean swap = false;
            if (Math.abs(a) < Math.abs(b)) {
                swap = true;
                double t = a;
                a = b;
                b = t;
                t = CX;
                CX = CY;
                CY = t;
            }
            List<Point2D.Double> res = new ArrayList<Point2D.Double>();
            double A = a * a + b * b;
            double B = 2.0 * b * (c + a * CX) - 2.0 * a * a * CY;
            double C = sqr(c + a * CX) + a * a * (CY * CY - R * R);
            double d = B * B - 4 * A * C;
            if (d < -eps)
                return res;
            d = Math.sqrt(d < 0 ? 0 : d);
            double y1 = (-B + d) / (2 * A);
            double x1 = (-c - b * y1) / a;
            double y2 = (-B - d) / (2 * A);
            double x2 = (-c - b * y2) / a;
            if (swap) {
                double t = x1;
                x1 = y1;
                y1 = t;
                t = x2;
                x2 = y2;
                y2 = t;
            }
            res.add(new Point2D.Double(x1, y1));
            if (d > eps)
                res.add(new Point2D.Double(x2, y2));
            return res;
        }

        public static List<Point2D.Double> circleCircleIntersection(Circle c1,
                Circle c2) {
            if (quickHypot(c1.x - c2.x, c1.y - c2.y) < eps) {
                if (Math.abs(c1.r - c2.r) < eps) {
                    // infinity intersection points
                    return null;
                }
                return new ArrayList<Point2D.Double>();
            }
            c2.x -= c1.x;
            c2.y -= c1.y;
            double A = -2 * c2.x;
            double B = -2 * c2.y;
            double C = c2.x * c2.x + c2.y * c2.y + c1.r * c1.r - c2.r * c2.r;
            List<Point2D.Double> res = circleLineIntersection(new Circle(0, 0,
                    c1.r), new Line(A, B, C));
            for (Point2D.Double point : res) {
                point.x += c1.x;
                point.y += c1.y;
            }
            return res;
        }

        public static double circleCircleIntersectionArea(Circle c1, Circle c2) {
            double r = Math.min(c1.r, c2.r);
            double R = Math.max(c1.r, c2.r);
            double d = quickHypot(c1.x - c2.x, c1.y - c2.y);
            if (d < R - r + eps) {
                return Math.PI * r * r;
            }
            if (d > R + r - eps) {
                return 0;
            }
            double area = r
                    * r
                    * Math.acos((d * d + r * r - R * R) / 2 / d / r)
                    + R
                    * R
                    * Math.acos((d * d + R * R - r * r) / 2 / d / R)
                    - 0.5
                    * Math.sqrt((-d + r + R) * (d + r - R) * (d - r + R)
                            * (d + r + R));
            return area;
        }

        static Circle minEnclosingCircleWith2Points(List<Point> points,
                Point q1, Point q2) {
            Circle circle = getCircumCircle(q1, q2);
            for (int i = 0; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = getCircumCircle(q1, q2, points.get(i));
                }
            }
            return circle;
        }

        static Circle minEnclosingCircleWith1Point(List<Point> pointsList,
                Point q) {
            List<Point> points = new ArrayList<Point>(pointsList);
            Collections.shuffle(points);
            Circle circle = getCircumCircle(points.get(0), q);
            for (int i = 1; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = minEnclosingCircleWith2Points(
                            points.subList(0, i), points.get(i), q);
                }
            }
            return circle;
        }

        public static Circle minEnclosingCircle(Point[] pointsArray) {
            if (pointsArray.length == 0) {
                return new Circle(0, 0, 0);
            }
            if (pointsArray.length == 1) {
                return new Circle(pointsArray[0].x, pointsArray[0].y, 0);
            }
            List<Point> points = Arrays.asList(pointsArray);
            Collections.shuffle(points);
            Circle circle = getCircumCircle(points.get(0), points.get(1));
            for (int i = 2; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = minEnclosingCircleWith1Point(points.subList(0, i),
                            points.get(i));
                }
            }
            return circle;
        }
    }

}

class Graph {
    private static final int INF = Integer.MAX_VALUE;

    /****
     * g - graph as list sumiznosti s - number of vertix from bfs started n -
     * number of all vertixes p - array with indexes of all parent vertix for
     * each other d - array with distance from start vertix to each other [if g
     * - zvazhenii, d[to] = d[v] + weigth of edge]
     *
     * В результате поиска в ширину находится путь кратчайшей длины в
     * невзвешененном графе, т.е. путь, содержащий наименьшее число рёбер.
     * Алгоритм работает за , где — число вершин, — число рёбер.
     *
     * if (!used[to]) System.out.println("No path!"); else { ArrayList <Integer>
     * path = new ArrayList<Integer>(); for (int v = to; v != -1; v = p[v]) {
     * path.add(v); } reverse (path.begin(), path.end());
     * System.out.println("Path:") for (int i = 0; i < path.size(); ++i) {
     * System.out.println(path[i] + 1); } }
     ****/
    public static void bfs(int s, ArrayList<Integer>[] g) {
        int n = g.length;
        Queue<Integer> q = new LinkedList<Integer>();
        q.add(s);
        boolean[] used = new boolean[n];
        int[] d = new int[n];
        int[] p = new int[n];
        used[s] = true;
        p[s] = -1;
        while (!q.isEmpty()) {
            int v = q.poll();
            for (int i = 0; i < g[v].size(); ++i) {
                int to = g[v].get(i);
                if (!used[to]) {
                    used[to] = true;
                    q.add(to);
                    d[to] = d[v] + 1;
                    p[to] = v;
                }
            }
        }
    }

    /****
     * g - graph as list sumiznosti v - number of vertix from dfs calls n -
     * number of all vertixes used - array which shows be or not visited vertix
     *
     * В результате поиска в глубину находится лексикографически первый путь в
     * графе. Алгоритм работает за O (N+M).
     *
     *
     ****/
    static int n = 100500;  // вершин
    static int m = 100500;  // ребер
    static ArrayList<Integer>[] g = new ArrayList[n];
    static boolean[] used = new boolean[g.length];

    public static void dfs(int v) {
        used[v] = true;
        for (int i = 0; i < g[v].size(); i++) {
            int to = g[v].get(i);
            if (!used[to]) {
                dfs(to);
            }
        }
    }

    /****
     * g - graph as list sumiznosti n - number of all vertixes used - array
     * which shows be or not visited vertix
     *
     * ans - список із відсорченими вершинами
     *
     * Дан ориентированный граф с вершинами и рёбрами. Требуется перенумеровать
     * его вершины таким образом, чтобы каждое рёбро вело из вершины с меньшим
     * номером в вершину с большим. Иными словами, требуется найти перестановку
     * вершин (топологический порядок), соответствующую порядку, задаваемому
     * всеми рёбрами графа.
     *
     ****/
    static ArrayList<Integer> ans = new ArrayList<Integer>();

    public static void topologicalSort() {
        for (int i = 0; i < n; ++i)
            used[i] = false;
        ans.clear();
        for (int i = 0; i < n; ++i)
            if (!used[i])
                dfs(i);
        Collections.reverse(ans);
    }

    class Pair {
        int first;
        int second;
        public Pair(int to, int len) {
            first = to;
            second = len;
        }
    }

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

    /**
     * O(n^2 + m)
     * Дан ориентированный или неориентированный взвешенный граф с n вершинами и m рёбрами.
     * Веса всех рёбер неотрицательны. Указана некоторая стартовая вершина s.
     * Требуется найти длины кратчайших путей из вершины s во все остальные вершины,
     * а также предоставить способ вывода самих кратчайших путей.
     *
     * После выполнения всех итераций в массиве d[] оказываются длины кратчайших путей до всех вершин,
     * а в массиве p[] — предки всех вершин (кроме стартовой s). Восстановить путь до любой вершины t можно следующим образом:
     *
     * vector<int> path;
     * for (int v=t; v!=s; v=p[v])
     *  path.push_back (v);
     *  path.push_back (s);
     *  reverse (path.begin(), path.end());
     */
    public static void Dejkstra(int s, ArrayList<Pair>[] g) {
        int[]d = new int[n];
        int[]p = new int[n];
        Arrays.fill(d, INF);
        d[s] = 0;
        boolean[]u = new boolean[n];
        for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                if (!u[j] && (v == -1 || d[j] < d[v]))
                    v = j;
            if (d[v] == INF)
                break;
            u[v] = true;

            for (int j=0; j<g[v].size(); ++j) {
                int to = g[v].get(j).first,
                    len = g[v].get(j).second;
                if (d[v] + len < d[to]) {
                    d[to] = d[v] + len;
                    p[to] = v;
                }
            }
        }
    }

    /**
     * O(N*M)
     * Пусть дан ориентированный взвешенный граф G с n вершинами и m рёбрами,
     * и указана некоторая вершина v. Требуется найти длины кратчайших путей от вершины v до всех остальных вершин.
     *
     * В отличие от алгоритма Дейкстры, этот алгоритм применим также и к графам, содержащим рёбра отрицательного веса.
     * Впрочем, если граф содержит отрицательный цикл, то, понятно, кратчайшего пути до некоторых вершин может
     * не существовать (по причине того, что вес кратчайшего пути должен быть равен минус бесконечности);
     * впрочем, этот алгоритм можно модифицировать, чтобы он сигнализировал о наличии цикла отрицательного веса,
     * или даже выводил сам этот цикл.
     *
     * Заведём массив расстояний d[], который после отработки алгоритма будет содержать ответ на задачу.
     *
     * if (d[t] == INF)
     *      cout << "No path from " << v << " to " << t << ".";
     *  else {
     *      vector<int> path;
     *      for (int cur=t; cur!=-1; cur=p[cur])
     *          path.push_back (cur);
     *      reverse (path.begin(), path.end());
     *      cout << "Path from " << v << " to " << t << ": ";
     *      for (size_t i=0; i<path.size(); ++i)
     *          cout << path[i] << ' ';
     * }
     */
    public static void FordBellman(int v, ArrayList <Edge> e) {
        int[]d = new int[n];
        int[]p = new int[n];

        Arrays.fill(d, INF);
        Arrays.fill(p, -1);

        d[v] = 0;
        for (;;) {
            boolean any = false;
            for (int j=0; j<m; ++j)
                if (d[e.get(j).a] < INF)
                    if (d[e.get(j).b] > d[e.get(j).a] + e.get(j).cost) {
                        d[e.get(j).b] = d[e.get(j).a] + e.get(j).cost;
                        p[e.get(j).b] = e.get(j).a;

                        any = true;
                    }
            if (!any)  break;
        }
    }

    /**
     * O(N^3)
     * Дан ориентированный или неориентированный взвешенный граф G с n вершинами.
     * Требуется найти значения всех величин dij — длины кратчайшего пути из вершины i в вершину j.
     *
     * На вход программе подаётся граф, заданный в виде матрицы смежности — двумерного массива d[][] размера n*n,
     * в котором каждый элемент задаёт длину ребра между соответствующими вершинами.
     * Требуется, чтобы выполнялось d[i][i] = 0 для любых i.
     */
    public static void FloydWorshall(int[][]d) {
        for (int k=0; k<n; ++k)
            for (int i=0; i<n; ++i)
                for (int j=0; j<n; ++j)
                    if (d[i][k] < INF && d[k][j] < INF)
                        d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
    }

    /**
     * O(n^2)
     *
     * Дан взвешенный неориентированный граф G с n вершинами и m рёбрами.
     * Требуется найти такое поддерево этого графа, которое бы соединяло все его вершины,
     * и при этом обладало наименьшим возможным весом (т.е. суммой весов рёбер).
     * Поддерево — это набор рёбер, соединяющих все вершины, причём из любой вершины можно
     * добраться до любой другой ровно одним простым путём.
     *
     * Такое поддерево называется минимальным остовным деревом или просто минимальным остовом.
     * Легко понять, что любой остов обязательно будет содержать n - 1 ребро.
     * В естественной постановке эта задача звучит следующим образом: есть n городов, и для каждой
     * пары известна стоимость соединения их дорогой (либо известно, что соединить их нельзя).
     * Требуется соединить все города так, чтобы можно было доехать из любого города в другой,
     * а при этом стоимость прокладки дорог была бы минимальной.
     *
     *
     * На вход подаются число вершин n и матрица g[][] размера n*n,
     * в которой отмечены веса рёбер, и стоят числа INF, если соответствующее ребро отсутствует.
     * Алгоритм поддерживает три массива: флаг used[i] = true означает, что вершина i включена в остов,
     * величина min_e[i] хранит вес наименьшего допустимого ребра из вершины i,
     * а элемент sel_e[i] содержит конец этого наименьшего ребра (это нужно для вывода рёбер в ответе).
     * Алгоритм делает n шагов, на каждом из которых выбирает вершину v с наименьшей меткой min_e, помечает её used,
     * и затем просматривает все рёбра из этой вершины, пересчитывая их метки.   *
     */
    public static void Prima(int g[][]) {
        boolean[]used = new boolean[n];
        int[]min_e = new int[n];
        int[]sel_e = new int[n];
        Arrays.fill(min_e, INF);
        Arrays.fill(sel_e, -1);

        min_e[0] = 0;
        for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                if (!used[j] && (v == -1 || min_e[j] < min_e[v]))
                    v = j;
            if (min_e[v] == INF) {
                System.out.println("No MST!");
                return;
            }

            used[v] = true;
            if (sel_e[v] != -1)
                System.out.println(v + " " + sel_e[v]);

            for (int to=0; to<n; ++to)
                if (g[v][to] < min_e[to]) {
                    min_e[to] = g[v][to];
                    sel_e[to] = v;
                }
        }
    }

    static int[]cl;
    static int[]p;
    static int cycle_st;
    static int cycle_end;

    /**
     * O(M)
     * Пусть дан ориентированный или неориентированный граф без петель и кратных рёбер.
     * Требуется проверить, является ли он ациклическим, а если не является, то найти любой цикл.
     */

    public static void FindCircle(ArrayList<Integer>[] g) {
        p = new int[n];
        Arrays.fill(p, -1);
        cl = new int[n];
        cycle_st = -1;
        for (int i=0; i<n; ++i)
            if (dfsForCircle(i, g))
                break;

        if (cycle_st == -1)
            System.out.println("Acyclic");
        else {
            System.out.println("Cyclic");
            ArrayList<Integer>cycle = new ArrayList<Integer>();;
            cycle.add(cycle_st);
            for (int v=cycle_end; v!=cycle_st; v=p[v])
                cycle.add(v);
            cycle.add(cycle_st);
            Collections.reverse(cycle);
            for (int i=0; i<cycle.size(); ++i)
                System.out.println(cycle.get(i)+1);
        }
    }

    public static boolean dfsForCircle (int v, ArrayList<Integer>[] g) {
        cl[v] = 1;
        for (int i=0; i<g[v].size(); ++i) {
            int to = g[v].get(i);
            if (cl[to] == 0) {
                p[to] = v;
                if (dfsForCircle (to, g))  return true;
            }
            else if (cl[to] == 1) {
                cycle_end = v;
                cycle_st = to;
                return true;
            }
        }
        cl[v] = 2;
        return false;
    }
}

class StringUtil {

    /**
     * Пусть дана строка s длины n. Тогда Z-функция от этой строки — это массив длины n, i-ый элемент
     * которого равен наибольшему числу символов, начиная с позиции i, совпадающих с первыми символами строки s.
     * Иными словами, z[i] — это наибольший общий префикс строки s и её i-го суффикса.
     *
     * Example:
     * "aaabaab"
     * z[0] = 0
     * z[1] = 2
     * z[2] = 1
     * z[3] = 0
     * z[4] = 2
     * z[5] = 1
     * z[6] = 0
     */
    public static int[] zFunction (String s) {
        int n = s.length();
        int[]z = new int[n];
        for (int i=1, l=0, r=0; i<n; ++i) {
            if (i <= r)
                z[i] = Math.min(r-i+1, z[i-l]);
            while (i+z[i] < n && s.charAt(z[i]) == s.charAt(i+z[i]))
                ++z[i];
            if (i+z[i]-1 > r) {
                l = i;
                r = i+z[i]-1;
            }
        }
        return z;
    }

    public static int[] prefixFunction(String s) {
        int n = s.length();
        int[] p = new int[n];
        for (int i = 1; i < n; i++) {
            int k = p[i - 1];
            while (k > 0 && s.charAt(k) != s.charAt(i)) {
                k = p[k - 1];
            }
            p[i] = k + (s.charAt(k) == s.charAt(i) ? 1 : 0);
        }
        return p;
    }

    /**
     * s - текст в якому шукаєм
     * pattern - слово яке шукаємо
     * Повертає -1 якщо немає входження, або індекс входження
     */
    public static int kmpMatcher(String s, String pattern) {
        int m = pattern.length();
        if (m == 0) {
            return 0;
        }
        int n = s.length();
        int[] p = prefixFunction(pattern);
        int k = 0;
        for (int i = 0; i < n; i++) {
            while (k > 0 && s.charAt(i) != pattern.charAt(k)) {
                k = p[k - 1];
            }
            if (s.charAt(i) == pattern.charAt(k)) {
                k++;
            }
            if (k == m) {
                return i - m + 1;
            }
        }
        return -1;
    }

    /**
     * Дана строка S и текст T, состоящие из маленьких латинских букв.
     * Требуется найти все вхождения строки S в текст T за время O (|S| + |T|).
     * Алгоритм. Посчитаем хэш для строки S. Посчитаем значения хэшей для всех префиксов строки T.
     * Теперь переберём все подстроки T длины |S| и каждую сравним с |S| за время O (1).
     */
    public static ArrayList<Integer> RabinKarp(String s, String t) {
        ArrayList<Integer>indexes = new ArrayList<Integer>();
        final int p = 31;
        long[]p_pow = new long[Math.max(s.length(), t.length())];
        p_pow[0] = 1;
        for (int i=1; i<p_pow.length; ++i)
            p_pow[i] = p_pow[i-1] * p;

        long[]h = new long[(t.length())];
        for (int i=0; i<t.length(); ++i)
        {
            h[i] = (t.charAt(i) - 'a' + 1) * p_pow[i];
            if (i!=0)  h[i] += h[i-1];
        }

        long h_s = 0;
        for (int i=0; i<s.length(); ++i)
            h_s += (s.charAt(i) - 'a' + 1) * p_pow[i];

        for (int i = 0; i + s.length() - 1 < t.length(); ++i)
        {
            long cur_h = h[i+s.length()-1];
            if (i!=0)  cur_h -= h[i-1];
            if (cur_h == h_s * p_pow[i])
                indexes.add(i);
        }
        return indexes;
    }

    public static void palindromsCount(String s) {
        int n = s.length();
        int[]d1 = new int[n];
        int l=0, r=-1;
        for (int i=0; i<n; ++i) {
            int k = (i>r ? 0 : Math.min (d1[l+r-i], r-i)) + 1;
            while (i+k < n && i-k >= 0 && s.charAt(i+k) == s.charAt(i-k))  ++k;
            d1[i] = k--;
            if (i+k > r) {
                l = i-k;
                r = i+k;
            }
        }

        int[]d2 = new int[n];
        l=0;
        r=-1;
        for (int i=0; i<n; ++i) {
            int k = (i>r ? 0 : Math.min (d2[l+r-i+1], r-i+1)) + 1;
            while (i+k-1 < n && i-k >= 0 && s.charAt(i+k-1) == s.charAt(i-k))  ++k;
            d2[i] = --k;
            if (i+k-1 > r) {
                l = i-k;
                r = i+k-1;
            }
        }
    }
}

class Combinatorica {
    /**
     * Перестановка з n - елементів
     * P = n!
     */
    public static long P(int n) {
        long ans = 1;
        if (n == 0) return 0;
        while (n > 0) {
            ans *= n;
            n--;
        }
        return ans;
    }

    /**
     * Кількість можливих m - елементних множин з множини з n елементів.
     * С(m, n) = n! / (m! * (n - m)!)   m <= n
     */
    public static long C(int m, int n) {
        if (m == 0 || m == n) return 1;
        long a = Combinatorica.P(n);
        long b = Combinatorica.P(m);
        long c = Combinatorica.P(n - m);
        return a / b / c;
    }

    /**
     * Кількість різних комбінацій із n елементів по m елементів з повтореннями становить
     * C(n - 1, n + m - 1) = C(m, n + m - 1)
     */
    public static long CwithRepeat(int n, int m) {
        return C(n - 1, n + m - 1);
    }

    /**
     * Кількість упорядкованих m-елементних підмножин n-елементної множини, всі m елементів якої різні
     */
    public static long A(int m, int n) {
        return Combinatorica.P(n) / Combinatorica.P(n - m);
    }
 }

class Matrix {
    /**
     * Додати дві матриці
     * @param a - матриця1
     * @param b - матриця2
     * @return нова матриця (а + б)
     */
    public static long[][] matrixAdd(long[][] a, long[][] b) {
        int n = a.length;
        int m = a[0].length;
        long[][] res = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                res[i][j] = a[i][j] + b[i][j];
            }
        }
        return res;
    }

    /**
     * Множення двох матриць
     * @param a - матриця1
     * @param b - матриця2
     * @return нова матриця (а * б)
     */
    public static long[][] matrixMul(long[][] a, long[][] b) {
        int n = a.length;
        int m = a[0].length;
        int k = b[0].length;
        long[][] res = new long[n][k];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < k; j++) {
                for (int p = 0; p < m; p++) {
                    res[i][j] = res[i][j] + a[i][p] * b[p][j];
                }
            }
        }
        return res;
    }

    /**
     * Піднести матрицю до степеня P
     * @param a - матриця
     * @param P - степінь
     * @return нова матриця a^P
     */
    public static long[][] matrixPow(long[][] a, long p) {
        if (p == 0) {
            return matrixUnit(a.length);
        } else if (p % 2 == 0) {
            return matrixPow(matrixMul(a, a), p / 2);
        } else {
            return matrixMul(a, matrixPow(a, p - 1));
        }
    }

    public static long[][] matrixPowSum(long[][] a, long p) {
        int n = a.length;
        if (p == 0) {
            return new long[n][n];
        }
        if (p % 2 == 0) {
            return matrixMul(matrixPowSum(a, p / 2),
                    matrixAdd(matrixUnit(n), matrixPow(a, p / 2)));
        } else {
            return matrixAdd(a, matrixMul(matrixPowSum(a, p - 1), a));
        }
    }

    /**
     * Cтворення одиничної матриці розміром n*n
     * @param n
     * @return матриця заповнена одиницями.
     */
    public static long[][] matrixUnit(int n) {
        long[][] res = new long[n][n];
        for (int i = 0; i < n; ++i) {
            res[i][i] = 1;
        }
        return res;
    }
}

class IO_Type {

    public static String CONSOLE = "console";
    public static String FILE = "file";

}

class BigIntegerUtil {
    public static BigInteger pow(BigInteger a, int exponent) {
        return a.pow(exponent);
    }
    public static BigInteger subtract(BigInteger a, BigInteger b) {
        return a.subtract(b);
    }
    public static BigInteger add(BigInteger a, BigInteger b) {
        return a.add(b);
    }
    public static BigInteger multiply(BigInteger a, BigInteger b) {
        return a.multiply(b);
    }
    public static BigInteger divide(BigInteger a, BigInteger b) {
        return a.divide(b);
    }
}

class FastScanner {

    BufferedReader br;
    StringTokenizer st;

    FastScanner getScanner() {
        return this;
    }

    FastScanner(String type) {
        if (type.equals("console")) {
            FastScanner(System.in);
        }
    }

    FastScanner(String type, String inFileName) {
        if (type.equals("file")) {
            File f = new File(inFileName);
            try {
                FastScanner(new FileInputStream(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    void FastScanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
    }

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                System.err.println(e);
                return "";
            }
        }
        return st.nextToken();
    }

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

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

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

    float nextFloat() {
        return Float.parseFloat(next());
    }

    BigInteger nextBigInt() {
        return new BigInteger(next());
    }

    void close() {
        try {
            br.close();
        } catch (IOException e) {
        }
    }
}

class FastWriter {

    PrintWriter pw;

    PrintWriter getWriter() {
        return pw;
    }

    FastWriter(String type) {
        FastWriter(type);
    }

    FastWriter(String type, String outFileName) {
        FastWriter(type, outFileName);
    }

    PrintWriter FastWriter(String type) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        return pw;
    }

    PrintWriter FastWriter(String type, String outFileName) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        else if (type.equals("file")) {
            try {
                pw = new PrintWriter(new File(outFileName));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        return pw;
    }
}

/***
*   Help:
*   https://sites.google.com/site/indy256/algo/
*   http://e-maxx.ru/algo/
*/

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

public class prob {

    static Scanner sc;
    static PrintWriter pw;
    static int[][] a;
    static int n;

    public static void main(String[] args) {
        sc = new Scanner(System.in);
        pw = new PrintWriter(System.out);
        try{
            n = sc.nextInt();
            a = new int[n][n];
            for(int i = 0; i < n; i++)
                for(int j = 0; j < n; j++)
                    a[i][j] = sc.nextInt();
            if(n == 1) {
                pw.println(a[0][0]);
                return;
            }
            long s = 0;
            for(int i = 0; i < n; i++)
                s += a[i][i] + a[n - i - 1][i] +
                    a[(n - 1) / 2 + 1][i] + a[i][(n - 1) / 2 + 1];
            s -= 3 * a[(n - 1) / 2 + 1][(n - 1) / 2 + 1];
            pw.println(s);
        }
        finally {
            pw.close();
        }
    }
}

import java.util.HashSet;
import java.util.Scanner;

public class A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		byte n = sc.nextByte(), mid = (byte) ((n - 1) / 2);
		long sum = 0;
		HashSet<String> g = new HashSet<String>();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				byte e = sc.nextByte();
				if (i == j || i == mid || j == mid || n - i - 1 == j
						|| n - j - 1 == i)
					if (!g.contains(i + "" + j)) {
						sum += e;
						g.add(i + "" + j);
					}
			}
		}
		System.out.println(sum);
	}
}

import java.util.HashSet;
import java.util.Scanner;

public class A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), mid = (n - 1) / 2;
		long sum = 0;
		HashSet<String> g = new HashSet<String>();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				int e = sc.nextInt();
				if (i == j || i == mid || j == mid || n - i - 1 == j
						|| n - j - 1 == i)
					if (!g.contains(i + "" + j)) {
						sum += e;
						g.add(i + "" + j);
					}
			}
		}
		System.out.println(sum);
	}
}

import java.util.HashSet;
import java.util.Scanner;

public class A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), mid = (n - 1) / 2;
		long sum = 0;
		HashSet<String> g = new HashSet<String>();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				int e = sc.nextByte();
				if (i == j || i == mid || j == mid || n - i - 1 == j
						|| n - j - 1 == i)
					if (!g.contains(i + "" + j)) {
						sum += e;
						g.add(i + "" + j);
					}
			}
		}
		System.out.println(sum);
	}
}

import java.util.*;
public class ABA {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N =  sc.nextInt();
		int[][] array = new int[N][N];
		boolean[][] B = new boolean[N][N];
		long ans = 0;
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				array[a][b]=sc.nextInt();
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==b){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			for(int b=0;b<N;b++){
				if(a==(N-1-b)){
					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}
			}
		}
		for(int a=0;a<N;a++){
			//for(int b=0;b<N;b++){
			int b = N/2;

					if(!B[a][b]){
						B[a][b]=true;
						ans+=array[a][b];
					}
				}

		for(int a=0;a<N;a++){
		//for(int b=0;b<N;b++){
		int b = N/2;

				if(!B[b][a]){
					B[a][b]=true;
					ans+=array[a][b];
				}
			}

		System.out.println(ans);

	}

}

import java.util.Scanner;

public class GoodElements {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int n = in.nextInt();
	long sum = 0;
	int mid = ((n-1)/2);
	int i=1,j=1;
	int x = 0;
	while (j>n) {
		if (i<=n) {
			if ((i==j) || (6-i==j) || (i-1== mid) || (j-1==mid))
				x =in.nextInt();
				sum+=x;
				i++;
		}
		else {
			j++;
			i=1;
		}
	}
	System.out.println(sum);
}
}

import java.util.Scanner;

public class GoodElements {
public static void main(String[] args)
	{
	Scanner in = new Scanner(System.in);
	int n = in.nextInt();
	long sum = 0;
	int mid = ((n-1)/2);
	int x = 0;
		for (int i = 0;i<n;i++)
			for (int j = 0;j<n;j++) {
				if ((i==j) || (i==mid) || (j==mid) || (i+j==n-1)) {
				x=in.nextInt();
				sum+=x;
				}
			}
	System.out.println(sum);
}
}

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

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";

	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{

			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}

	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
		catch (NullPointerException e)
		{
			line=null;

		}

	}

	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}

	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	public static void main(String [] argv)
	{
		String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}

	public void readFInput()
	{
		for(;;)
		{
			try
			{
				readNextLine();
				FInput+=line+" ";
			}
			catch(Exception e)
			{
				break;
			}
		}
		inputParser = new StringTokenizer(FInput, " ");
	}

	public A(String inputFile)
	{
		openInput(inputFile);

		readNextLine();
		int ret=0;

		int N=NextInt();
		boolean [] [] p = new boolean [N][N];

		for(int i=0; i<N; i++)
		{
			readNextLine();
			for(int j=0; j<N;j++)
			{
				int a=NextInt();
				p[i][j]=false;
				if(i==j)p[i][j]=true;
				if(i==N-j-1)p[i][j]=true;
				if(i==j+2)p[i][j]=true;
				if(i==j-2)p[i][j]=true;
				if(i==N-j+1)p[i][j]=true;
				if(i==N-j-3)p[i][j]=true;
				if(i==(N-1)/2)p[i][j]=true;
				if(j==(N-1)/2)p[i][j]=true;
				if(p[i][j])ret+=a;
			}

		}

		System.out.println(ret);

        closeInput();
	}

	private class Item implements Comparable<Item>
	{
		int cnt,buy,sell;
		Item (int a, int b, int c)
		{
			buy=a;
			sell=b;
			cnt=c;
		}
		public int compareTo(Item d)
		{
			return d.sell-d.buy-(sell-buy);
		}
	}

}

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

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";

	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{

			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}

	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
		catch (NullPointerException e)
		{
			line=null;

		}

	}

	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}

	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	public static void main(String [] argv)
	{
		String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}

	public void readFInput()
	{
		for(;;)
		{
			try
			{
				readNextLine();
				FInput+=line+" ";
			}
			catch(Exception e)
			{
				break;
			}
		}
		inputParser = new StringTokenizer(FInput, " ");
	}

	public A(String inputFile)
	{
		openInput(inputFile);

		readNextLine();
		int ret=0;

		int N=NextInt();
		boolean [] [] p = new boolean [N][N];

		for(int i=0; i<N; i++)
		{
			//readNextLine();
			for(int j=0; j<N;j++)
			{
				int a=1;//NextInt();
				p[i][j]=false;
				if(i==j)p[i][j]=true;
				if(i==N-j-1)p[i][j]=true;
				/*if(i==j+2)p[i][j]=true;
				if(i==j-2)p[i][j]=true;
				if(i==N-j+1)p[i][j]=true;
				if(i==N-j-3)p[i][j]=true;*/
				if(i==(N-1)/2)p[i][j]=true;
				if(j==(N-1)/2)p[i][j]=true;
				if(p[i][j])ret+=a;
				//System.out.print(p[i][j]?'X':'.');
			}
			//System.out.println();
		}

		System.out.println(ret);

        closeInput();
	}

	private class Item implements Comparable<Item>
	{
		int cnt,buy,sell;
		Item (int a, int b, int c)
		{
			buy=a;
			sell=b;
			cnt=c;
		}
		public int compareTo(Item d)
		{
			return d.sell-d.buy-(sell-buy);
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    static int n;
    static int[][] a;

    public static void main(String[] args) {
        PrintWriter pw = new PrintWriter(System.out);
        Input(new FastReader());
        Solve(pw);
        pw.flush();
        pw.close();
    }

    public static void Solve(PrintWriter pw) {
        ArrayList<Integer> ll = new ArrayList<>();
        int sum = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; ++j) {
                sum += a[i][j];

            }
        }
        if (n > 3) {
            for (int i = 0; i < n; i++) {
                if (i % 2 != 0) {
                    ll.add(i);
                }
            }
            int lowRow = 0;
            int highRow = n - 1;
            for (int i = 0; i < ll.size(); ++i) {
                sum -= a[lowRow][i];
                sum -= a[highRow][i];
                sum -= a[i][highRow];
                sum -= a[i][lowRow];
            }
            pw.println(sum);
        } else {
            pw.println(sum);
        }
    }

    public static void Input(FastReader input) {
        n = input.nextInt();
        a = new int[n][n];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                a[i][j] = input.nextInt();
            }
        }

    }

    public static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            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 string = "";
            try {
                string = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return string;
        }

        char nextChar() {
            return next().charAt(0);
        }

        String[] nextStringArray() {
            String[] str = null;
            try {
                str = this.br.readLine().trim().split(" ");
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        int[] nextIntArray() {
            String[] data = nextStringArray();
            int[] a = new int[data.length];

            for (int i = 0; i < a.length; i++) {
                a[i] = Integer.parseInt(data[i]);
            }

            return a;
        }

        Integer[] nextIntegerArray() {
            String[] data = nextStringArray();
            Integer[] a = new Integer[data.length];

            for (int i = 0; i < a.length; i++) {
                a[i] = Integer.parseInt(data[i]);
            }

            return a;
        }

        long[] nextLongArray() {
            String[] data = nextStringArray();
            long[] a = new long[data.length];

            for (int i = 0; i < a.length; i++) {
                a[i] = Long.parseLong(data[i]);
            }

            return a;
        }

        public boolean hasNext() throws IOException {
            if (st != null && st.hasMoreTokens()) {
                return true;
            }
            String s = br.readLine();
            if (s == null || s.isEmpty()) {
                return false;
            }
            st = new StringTokenizer(s);
            return true;
        }

    }

}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[][] matrix = new int[n][n];
		int sum = 0;

		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				matrix[i][j] = in.nextInt();
				if (n == 5) {
					if (i == 0) {
					if (j == 1 || j == 3) {
						matrix[i][j] = 0;
					}
				}
				if (i == 1) {
					if (j == 0 || j == 4) {
						matrix[i][j] = 0;
					}
				}
				if (i == 3) {
					if (j == 0 || j == 4) {
						matrix[i][j] = 0;
					}
				}
				if (i == 4) {
					if (j == 1 || j == 3) {
						matrix[i][j] = 0;
					}
				}
				}
				sum += matrix[i][j];
			}
		}
		System.out.println(sum);
	}
}

import java.util.Scanner;
import java.util.Arrays;
public class cf177a2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n;
        n=sc.nextInt();
        int a;
        int s=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                a=sc.nextInt();
                if(i==j)
                {
                    s=s+a;
                }
                else if(j==i+1)
                {
                  s=s+a;
                }
                else if(2*i==n-1)
                {
                    s=s+a;
                }
                else if(2*j==n-1)
                {
                    s=s+a;
                }
            }
        }
        System.out.print(s+"\n");
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.FileReader;
import java.io.FileWriter;
//import java.lang.StringBuilder;
import java.util.StringTokenizer;
//import java.lang.Comparable;
//import java.util.Arrays;
//import java.util.HashMap;
//import java.util.ArrayList;
//import java.util.LinkedList;

public class GoodMatrixElements {

    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter out = new PrintWriter(System.out);
    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) throws IOException {
        //StringTokenizer st = new StringTokenizer(in.readLine());
        //BufferedReader in = new BufferedReader(new FileReader("input.txt"));
        //PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
        int n = Integer.parseInt(in.readLine());
        int m = n / 2;
        int sum = 0;
        int g = 0;
        int d = n - 1;
        for(int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(in.readLine());
            if(i == m) {
                for(int j = 0; j < n; j++) {
                    sum += Integer.parseInt(st.nextToken());
                }
            } else {
                for(int j = 0; j < n; j++) {
                    if(j == g || j == m || j == d) {
                        sum += Integer.parseInt(st.nextToken());
                    }
                }
            }
            g++;
            d--;
        }
        out.print(sum);
        out.close();
    }
}

import java.util.Scanner;

public class AntonIMnogogranniki {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int i, j, n = in.nextInt(),a[][];
		a = new int[n+1][n+1];
		for(i = 1;i<=n;i++) {
			for(j = 1;j<=n;j++) {
				a[i][j] = in.nextInt();
			}
		}
		long sum = 0;
		for(i = 1;i<=n;i++) {
			sum+=(a[n/2][i]+a[i][n/2]+a[i][i]+a[i][n-i+1]);
		}
		sum-=(3*a[n/2][n/2]);
		System.out.println(sum);
	}

}

import java.util.Scanner;

public class AntonIMnogogranniki {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int i, j, n = in.nextInt(),a[][];
		a = new int[n+1][n+1];
		if(n == 1) {
			a[1][1] = in.nextInt();
			System.out.println(a[1][1]);
			return;
		}
		for(i = 1;i<=n;i++) {
			for(j = 1;j<=n;j++) {
				a[i][j] = in.nextInt();
			}
		}
		long sum = 0;
		for(i = 1;i<=n;i++) {
			sum+=(a[n/2][i]+a[i][n/2]+a[i][i]+a[i][n-i+1]);
		}
		sum-=(3*a[n/2][n/2]);
		System.out.println(sum);
	}

}

import java.util.*;
public class Problem12 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int[][] arr = new int[n][n];
		for(int i=0;i<n;i++) {
			for(int j=0;j<n;j++) {
				arr[i][j]=sc.nextInt();
			}
		}
		int mid=n/2;
		int sum=0;
		for(int u=0;u<n;u++) {
			sum+=arr[u][mid];
			sum+=arr[mid][u];
		}
		sum-=arr[mid][mid];
		for(int w=0;w<n;w++) {
			int temp=n-w-1;
			sum+=arr[w][w];
			sum+=arr[temp][temp];
		}
		sum-=2*arr[mid][mid];
		System.out.println(sum);
	}
}

import java.awt.geom.Point2D;
import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

    FastScanner in;
    PrintWriter out;

    public static final int MOD = 1000 * 1000 * 1000 + 7;
    public static final int INF = Integer.MAX_VALUE;

    /*  SOLUTION    */
    public void solve() {

        int n = in.nextInt();
        int[][]tab = new int[n][n];
        int sum = 0;

        for (int i = 0; i < tab.length; i++) {
            for (int j = 0; j < tab.length; j++) {
                tab[i][j] = in.nextInt();
            }
        }

        if (n == 1) {
            out.println(tab[0][0]);
            return;
        }
        if (n == 2) {
            sum += tab[0][0];
            sum += tab[0][tab.length - 1];
            sum += tab[tab.length - 1][0];
            sum += tab[tab.length - 1][tab.length - 1];
            out.println(sum);
            return;
        }
        if (n >= 3) {
            int s = (n - 1) / 2;
            int D = (n-1)/2;
            for (int i = 0; i <= D; i++, s--) {
                for (int j = s; j < tab.length - s; j++) {
                    sum += tab[i][j];
//                  System.out.println(tab[i][j]);
                }
            }
            s+=2;
            for (int i = D+1; i < tab.length; i++, s++) {
                for (int j = s; j < tab.length - s; j++) {
                    sum += tab[i][j];
//                  System.out.println(tab[i][j]);
                }
            }

            sum += tab[0][0];
            sum += tab[0][tab.length - 1];
            sum += tab[tab.length - 1][0];
            sum += tab[tab.length - 1][tab.length - 1];
            out.println(sum);
        }

    }

    Main() {
        in = new FastScanner(IO_Type.CONSOLE).getScanner();
        out = new FastWriter(IO_Type.CONSOLE).getWriter();
//       in = new FastScanner(IO_Type.FILE, "input.txt").getScanner();
//       out = new FastWriter(IO_Type.FILE, "output.txt").getWriter();
    }

    public static void main(String[] args) {
        Main task = new Main();
        task.solve();
        task.close();
    }

    public void close() {
        in.close();
        out.close();
    }
}

class Algebra {
    /****
     * Number of co-prime numbers on [1, n]. Number a is Co-prime if gcd (a, n)
     * == 1 O (sqrt(n))
     ****/
    public static int phi(int n) {
        int result = n;
        for (int i = 2; i * i <= n; ++i) {
            if (n % i == 0) {
                while (n % i == 0) {
                    n /= i;
                }
                result -= result / i;
            }
        }
        if (n > 1) {
            result -= result / n;
        }
        return result;
    }

    /****
     * Raise number a to power of n. O (log n)
     ****/
    public static int binpow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1)
                res *= a;
            a *= a;
            n >>= 1;
        }
        return res;
    }

    /****
     * Finding the greatest common divisor of two numbers. O (log min(a, b))
     ****/
    public static int gcd(int a, int b) {
        return (b != 0) ? gcd(b, a % b) : a;
    }

    /****
     * Finding the lowest common multiple of two numbers. O (log min(a, b))
     ****/
    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    /****
     * Eratosthenes Sieve of numbers - [0..n]. True - simple, False - not
     * simple. O (n log log n)
     ****/
    public static boolean[] sieveOfEratosthenes(int n) {
        boolean[] prime = new boolean[n + 1];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i <= n; ++i) {
            if (prime[i]) {
                if (i * 1L * i <= n) {
                    for (int j = i * i; j <= n; j += i) {
                        prime[j] = false;
                    }
                }
            }
        }
        return prime;
    }

    /****
     * Кодом Грея называется такая система нумерования неотрицательных чисел,
     * когда коды двух соседних чисел отличаются ровно в одном бите.
     * Например, для чисел длины 3 бита имеем такую последовательность кодов Грея: 000, 001, 011, 010, 110, 111, 101, 100.
     * Например, codeGray(4) = 6.
     ****/
    public static int codeGray (int n) {
        return n ^ (n >> 1);
    }

    /**
     * Даны два числа: n и k. Требуется посчитать, с какой степенью делитель k входит в число n!,
     *  т.е. найти наибольшее x такое, что делится на k^x.
     */
    public static int fact_pow (int n, int k) {
        int res = 0;
        while (n!=0) {
            n /= k;
            res += n;
        }
        return res;
    }

    /**
     * O(sqrt(N))
     * Факторизує число n
     * Вертає мапу з ключом - простим числом, і його значення, кількістю дільників.
     */
    public static TreeMap<Long, Integer> factorize(long n) {
        TreeMap<Long, Integer> factors = new TreeMap<Long, Integer>();
        for (long d = 2; n > 1;) {
            int cnt = 0;
            while (n % d == 0) {
                cnt++;
                n /= d;
            }
            if (cnt > 0) {
                factors.put(d, cnt);
            }
            d += (d == 2) ? 1 : 2;
            if (d * d > n) {
                d = n;
            }
        }
        return factors;
    }

    /**
     * O(sqrt(N))
     * Знаходження дільників числа n.
     */
    public static int[] getDivisors(int n) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 1; (long) i * i <= n; i++) {
            if (n % i == 0) {
                list.add(i);
                if (i * i != n) {
                    list.add(n / i);
                }
            }
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        Arrays.sort(res);
        return res;
    }
}

class Geometry {
    /**
     * Многоугольник без самопересечений называется решётчатым, если все его вершины находятся
     * в точках с целочисленными координатами (в декартовой системе координат).
     * Пусть дан некоторый решётчатый многоугольник, с ненулевой площадью.
     * Обозначим его площадь через S;
     * количество точек с целочисленными координатами, лежащих строго внутри многоугольника — через I;
     * количество точек с целочисленными координатами, лежащих на сторонах многоугольника — через B.
     */
    public static double Pika(int i, int b) {
        return i + b / 2 - 1;
    }

    static class PolygonAlgo {
        static final double eps = 1e-9;

        public static int sign(double a) {
            return Math.abs(a) < eps ? 0 : a < 0 ? -1 : 1;
        }

        public static double sqr(double x) {
            return x * x;
        }

        /**
         * Повертає значення гіпотенузи для заданих x,y.
         */
        public static double quickHypot(double x, double y) {
            return Math.sqrt(x * x + y * y);
        }

        public static class Point implements Comparable<Point> {
            double x, y;

            public Point(double x, double y) {
                this.x = x;
                this.y = y;
            }

            /**
             * Різниця двох точок
             * @return нова точка
             */
            public Point sub(Point b) {
                return new Point(x - b.x, y - b.y);
            }

            /**
             * Перетин двох точок
             * @return нова точка
             */
            public double cross(Point b) {
                return x * b.y - y * b.x;
            }

            public double dot(Point b) {
                return x * b.x + y * b.y;
            }

            /**
             * Сортування точок, спершу по x, у разі рівності x, сортування по y
             */
            public int compareTo(Point o) {
                int comp = sign(x - o.x);
                if (comp != 0)
                    return comp;
                return sign(y - o.y);
            }
        }

        public static class Line {
            double a, b, c;

            void norm() {
                double d = Math.sqrt(a * a + b * b);
                a /= d;
                b /= d;
                c /= d;
                if (a < -eps || a < eps && b < 0) {
                    a = -a;
                    b = -b;
                    c = -c;
                }
            }

            public Line(double a, double b, double c) {
                this.a = a;
                this.b = b;
                this.c = c;
                norm();
            }

            public Line(Point p1, Point p2) {
                a = +(p1.y - p2.y);
                b = -(p1.x - p2.x);
                c = p1.x * p2.y - p2.x * p1.y;
                norm();
            }

            public boolean parallel(Line line) {
                return sign(det(a, b, line.a, line.b)) == 0;
            }

            public boolean equivalent(Line line) {
                return sign(det(a, b, line.a, line.b)) == 0
                        && sign(det(a, c, line.a, line.c)) == 0
                        && sign(det(b, c, line.b, line.c)) == 0;
            }

            public double angle() {
                return Math.atan2(-a, b);
            }
        }

        public static double det(double a, double b, double c, double d) {
            return a * d - b * c;
        }

        public static double angle(Point a, Point p, Point b) {
            a = a.sub(p);
            b = b.sub(p);
            return Math.atan2(a.cross(b), a.dot(b));
        }

        public static double cross(Point a, Point b, Point c) {
            return b.sub(a).cross(c.sub(a));
        }

        public static int crossop(Point a, Point b, Point c) {
            return sign(cross(a, b, c));
        }

        public static boolean cw(Point a, Point b, Point c) {
            return crossop(a, b, c) < 0;
        }

        public static boolean ccw(Point a, Point b, Point c) {
            return crossop(a, b, c) > 0;
        }

        public static boolean isMiddle(double a, double m, double b) {
            return Math.abs(m - a) < eps || Math.abs(m - b) < eps
                    || (a < m) != (b < m);
        }

        public static boolean isMiddle(Point a, Point m, Point b) {
            return crossop(a, m, b) == 0 && isMiddle(a.x, m.x, b.x)
                    && isMiddle(a.y, m.y, b.y);
        }

        public static boolean isTouchIntersect(Point a, Point b, Point c,
                Point d) {
            return isMiddle(a, c, b) || isMiddle(a, d, b) || isMiddle(c, a, d)
                    || isMiddle(c, b, d);
        }

        public static boolean isCrossIntersect(Point a, Point b, Point c,
                Point d) {
            return crossop(a, b, c) * crossop(a, b, d) < 0
                    && crossop(c, d, a) * crossop(c, d, b) < 0;
        }

        public static boolean isIntersect(Point a, Point b, Point c, Point d) {
            return isCrossIntersect(a, b, c, d) || isTouchIntersect(a, b, c, d);
        }

        static boolean isIntersect2(double x1, double y1, double x2, double y2,
                double x3, double y3, double x4, double y4) {
            if (Math.max(x1, x2) < Math.min(x3, x4) - eps
                    || Math.max(x3, x4) < Math.min(x1, x2) - eps
                    || Math.max(y1, y2) < Math.min(y3, y4) - eps
                    || Math.max(y3, y4) < Math.min(y1, y2) - eps) {
                return false;
            }
            double z1 = (x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1);
            double z2 = (x4 - x1) * (y2 - y1) - (y4 - y1) * (x2 - x1);
            if (z1 < -eps && z2 < -eps || z1 > eps && z2 > eps) {
                return false;
            }
            double z3 = (x1 - x3) * (y4 - y3) - (y1 - y3) * (x4 - x3);
            double z4 = (x2 - x3) * (y4 - y3) - (y2 - y3) * (x4 - x3);
            if (z3 < -eps && z4 < -eps || z3 > eps && z4 > eps) {
                return false;
            }
            return true;
        }

        public static double signedArea(double[] x, double[] y) {
            int n = x.length;
            double s = 0;
            for (int i = 0; i < n; i++) {
                s += (x[(i + 1) % n] - x[i]) * (y[(i + 1) % n] + y[i]);
            }
            return s;
        }

        public static Point getIntersection(Point p1, Point p2, Point q1,
                Point q2) {
            return getIntersection(new Line(p1, p2), new Line(q1, q2));
        }

        public static Point getIntersection(Line A, Line B) {
            double a1 = A.a;
            double b1 = A.b;
            double c1 = A.c;
            double a2 = B.a;
            double b2 = B.b;
            double c2 = B.c;
            double det = a1 * b2 - a2 * b1;
            if (sign(det) == 0) {
                return null;
            }
            double x = -(c1 * b2 - c2 * b1) / det;
            double y = -(a1 * c2 - a2 * c1) / det;
            return new Point(x, y);
        }

        public static double pointToLineDistance(Point p, Line line) {
            return Math.abs(line.a * p.x + line.b * p.y + line.c)
                    / quickHypot(line.a, line.b);
        }

        public static double pointToSegmentDistance(Point p, Point a, Point b) {
            double dx = b.x - a.x;
            double dy = b.y - a.y;
            double px = p.x - a.x;
            double py = p.y - a.y;
            double squaredLength = dx * dx + dy * dy;
            double proj = dx * px + dy * py;
            if (proj < 0 || squaredLength < eps * eps) {
                return quickHypot(px, py);
            }
            if (proj > squaredLength) {
                return quickHypot(px - dx, py - dy);
            }
            return quickHypot(px - (double) proj / squaredLength * dx, py
                    - (double) proj / squaredLength * dy);
        }

        public static double pointToSegmentDistance2(Point p, Point a, Point b) {
            double s12 = sqr(a.x - b.x) + sqr(a.y - b.y);
            double s1 = sqr(p.x - a.x) + sqr(p.y - a.y);
            double s2 = sqr(p.x - b.x) + sqr(p.y - b.y);
            if (s12 > eps && Math.abs(s1 - s2) <= s12)
                return Math.abs(cross(p, a, b)) / Math.sqrt(s12);
            else
                return Math.sqrt(Math.min(s1, s2));
        }

        public static Point[] convexHull(Point[] p) {
            int n = p.length;
            if (n <= 1)
                return p;
            int k = 0;
            Arrays.sort(p);
            Point[] q = new Point[n * 2];
            for (int i = 0; i < n; q[k++] = p[i++])
                for (; k > 1 && !cw(q[k - 2], q[k - 1], p[i]); --k)
                    ;
            for (int i = n - 2, t = k; i >= 0; q[k++] = p[i--])
                for (; k > t && !cw(q[k - 2], q[k - 1], p[i]); --k)
                    ;
            Point[] res = new Point[k - 1 - (q[0].compareTo(q[1]) == 0 ? 1 : 0)];
            System.arraycopy(q, 0, res, 0, res.length);
            return res;
        }

        Point[] convexCut(Point[] poly, Point p1, Point p2) {
            int n = poly.length;
            ArrayList<Point> res = new ArrayList<Point>();
            for (int i = 0, j = n - 1; i < n; j = i++) {
                int d1 = sign(p2.sub(p1).cross(poly[i].sub(p1)));
                int d2 = sign(p2.sub(p1).cross(poly[j].sub(p1)));
                if (d1 >= 0)
                    res.add(poly[i]);
                if (d1 * d2 < 0)
                    res.add(getIntersection(p1, p2, poly[i], poly[j]));
            }
            return res.toArray(new Point[0]);
        }

        public static enum Location {
            BOUNDARY, INTERIOR, EXTERIOR;
        }

        public static Location pointInPolygon(Point p0, Point[] poly) {
            int n = poly.length;
            Point[] p = new Point[n];
            for (int i = 0; i < p.length; i++)
                p[i] = poly[i].sub(p0);
            int cnt = 0;
            for (int i = 0, j = n - 1; i < n; j = i++) {
                if (sign(p[i].y) == 0
                        && (sign(p[i].x) == 0 || sign(p[j].y) == 0
                                && (sign(p[i].x) < 0) != (sign(p[j].x) < 0)))
                    return Location.BOUNDARY;

                if (sign(p[i].y) > 0 != sign(p[j].y) > 0) {
                    double det = p[i].cross(p[j]);
                    if (sign(det) == 0)
                        return Location.BOUNDARY;
                    if (sign(det) > 0 != sign(p[j].y - p[i].y) > 0)
                        ++cnt;
                }
            }
            return cnt % 2 == 0 ? Location.EXTERIOR : Location.INTERIOR;
        }

        public static enum Position {
            LEFT, RIGHT, BEHIND, BEYOND, ORIGIN, DESTINATION, BETWEEN;
        }

        public static Position classify(Point a, Point b, Point p) {
            int s = crossop(a, b, p);
            if (s > eps) {
                return Position.LEFT;
            }
            if (s < -eps) {
                return Position.RIGHT;
            }
            if (sign(p.x - a.x) == 0 && sign(p.y - a.y) == 0) {
                return Position.ORIGIN;
            }
            if (sign(p.x - b.x) == 0 && sign(p.y - b.y) == 0) {
                return Position.DESTINATION;
            }
            // if (ax * bx < 0 || ay * by < 0) {
            if (isMiddle(a, b, p)) {
                return Position.BEYOND;
            }
            // if (ax * ax + ay * ay < bx * bx + by * by) {
            if (isMiddle(b, a, p)) {
                return Position.BEHIND;
            }
            return Position.BETWEEN;
        }
    }

    static class CircleAlgo {
        static final double eps = 1e-9;

        public static double sqr(double x) {
            return x * x;
        }

        public static double quickHypot(double x, double y) {
            return Math.sqrt(x * x + y * y);
        }

        public static class Point {
            double x, y;

            public Point(double x, double y) {
                this.x = x;
                this.y = y;
            }
        }

        public static class Circle {
            double r, x, y;

            public Circle(double x, double y, double r) {
                this.x = x;
                this.y = y;
                this.r = r;
            }

            public boolean contains(Point p) {
                return quickHypot(p.x - x, p.y - y) < r + eps;
            }
        }

        public static Circle getCircumCircle(Point a, Point b) {
            double x = (a.x + b.x) / 2.;
            double y = (a.y + b.y) / 2.;
            double r = quickHypot(a.x - x, a.y - y);
            return new Circle(x, y, r);
        }

        public static Circle getCircumCircle(Point a, Point b, Point c) {
            double Bx = b.x - a.x;
            double By = b.y - a.y;
            double Cx = c.x - a.x;
            double Cy = c.y - a.y;
            double d = 2 * (Bx * Cy - By * Cx);
            double z1 = Bx * Bx + By * By;
            double z2 = Cx * Cx + Cy * Cy;
            double cx = Cy * z1 - By * z2;
            double cy = Bx * z2 - Cx * z1;
            double x = (double) cx / d;
            double y = (double) cy / d;
            double r = quickHypot(x, y);
            return new Circle(x + a.x, y + a.y, r);
        }

        public static class Line {
            double a, b, c;

            public Line(double a, double b, double c) {
                this.a = a;
                this.b = b;
                this.c = c;
            }

            public Line(Point p1, Point p2) {
                a = +(p1.y - p2.y);
                b = -(p1.x - p2.x);
                c = p1.x * p2.y - p2.x * p1.y;
            }
        }

        // geometric solution
        public static List<Point2D.Double> circleLineIntersection(
                Circle circle, Line line) {
            double a = line.a;
            double b = line.b;
            double c = line.c + circle.x * a + circle.y * b;
            double r = circle.r;
            double aabb = a * a + b * b;
            List<Point2D.Double> res = new ArrayList<Point2D.Double>();
            double d = c * c / aabb - r * r;
            if (d > eps)
                return res;
            double x0 = -a * c / aabb;
            double y0 = -b * c / aabb;
            if (d > -eps) {
                res.add(new Point2D.Double(x0 + circle.x, y0 + circle.y));
                return res;
            }
            d /= -aabb;
            double k = Math.sqrt(d < 0 ? 0 : d);
            res.add(new Point2D.Double(x0 + k * b + circle.x, y0 - k * a
                    + circle.y));
            res.add(new Point2D.Double(x0 - k * b + circle.x, y0 + k * a
                    + circle.y));
            return res;
        }

        // algebraic solution
        public static List<Point2D.Double> circleLineIntersection2(
                Circle circle, Line line) {
            double a = line.a;
            double b = line.b;
            double c = line.c;
            double CX = circle.x, CY = circle.y;
            double R = circle.r;
            // ax+by+c=0
            // (by+c+aCX)^2+(ay-aCY)^2=(aR)^2
            boolean swap = false;
            if (Math.abs(a) < Math.abs(b)) {
                swap = true;
                double t = a;
                a = b;
                b = t;
                t = CX;
                CX = CY;
                CY = t;
            }
            List<Point2D.Double> res = new ArrayList<Point2D.Double>();
            double A = a * a + b * b;
            double B = 2.0 * b * (c + a * CX) - 2.0 * a * a * CY;
            double C = sqr(c + a * CX) + a * a * (CY * CY - R * R);
            double d = B * B - 4 * A * C;
            if (d < -eps)
                return res;
            d = Math.sqrt(d < 0 ? 0 : d);
            double y1 = (-B + d) / (2 * A);
            double x1 = (-c - b * y1) / a;
            double y2 = (-B - d) / (2 * A);
            double x2 = (-c - b * y2) / a;
            if (swap) {
                double t = x1;
                x1 = y1;
                y1 = t;
                t = x2;
                x2 = y2;
                y2 = t;
            }
            res.add(new Point2D.Double(x1, y1));
            if (d > eps)
                res.add(new Point2D.Double(x2, y2));
            return res;
        }

        public static List<Point2D.Double> circleCircleIntersection(Circle c1,
                Circle c2) {
            if (quickHypot(c1.x - c2.x, c1.y - c2.y) < eps) {
                if (Math.abs(c1.r - c2.r) < eps) {
                    // infinity intersection points
                    return null;
                }
                return new ArrayList<Point2D.Double>();
            }
            c2.x -= c1.x;
            c2.y -= c1.y;
            double A = -2 * c2.x;
            double B = -2 * c2.y;
            double C = c2.x * c2.x + c2.y * c2.y + c1.r * c1.r - c2.r * c2.r;
            List<Point2D.Double> res = circleLineIntersection(new Circle(0, 0,
                    c1.r), new Line(A, B, C));
            for (Point2D.Double point : res) {
                point.x += c1.x;
                point.y += c1.y;
            }
            return res;
        }

        public static double circleCircleIntersectionArea(Circle c1, Circle c2) {
            double r = Math.min(c1.r, c2.r);
            double R = Math.max(c1.r, c2.r);
            double d = quickHypot(c1.x - c2.x, c1.y - c2.y);
            if (d < R - r + eps) {
                return Math.PI * r * r;
            }
            if (d > R + r - eps) {
                return 0;
            }
            double area = r
                    * r
                    * Math.acos((d * d + r * r - R * R) / 2 / d / r)
                    + R
                    * R
                    * Math.acos((d * d + R * R - r * r) / 2 / d / R)
                    - 0.5
                    * Math.sqrt((-d + r + R) * (d + r - R) * (d - r + R)
                            * (d + r + R));
            return area;
        }

        static Circle minEnclosingCircleWith2Points(List<Point> points,
                Point q1, Point q2) {
            Circle circle = getCircumCircle(q1, q2);
            for (int i = 0; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = getCircumCircle(q1, q2, points.get(i));
                }
            }
            return circle;
        }

        static Circle minEnclosingCircleWith1Point(List<Point> pointsList,
                Point q) {
            List<Point> points = new ArrayList<Point>(pointsList);
            Collections.shuffle(points);
            Circle circle = getCircumCircle(points.get(0), q);
            for (int i = 1; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = minEnclosingCircleWith2Points(
                            points.subList(0, i), points.get(i), q);
                }
            }
            return circle;
        }

        public static Circle minEnclosingCircle(Point[] pointsArray) {
            if (pointsArray.length == 0) {
                return new Circle(0, 0, 0);
            }
            if (pointsArray.length == 1) {
                return new Circle(pointsArray[0].x, pointsArray[0].y, 0);
            }
            List<Point> points = Arrays.asList(pointsArray);
            Collections.shuffle(points);
            Circle circle = getCircumCircle(points.get(0), points.get(1));
            for (int i = 2; i < points.size(); i++) {
                if (!circle.contains(points.get(i))) {
                    circle = minEnclosingCircleWith1Point(points.subList(0, i),
                            points.get(i));
                }
            }
            return circle;
        }
    }

}

class Graph {
    private static final int INF = Integer.MAX_VALUE;

    /****
     * g - graph as list sumiznosti s - number of vertix from bfs started n -
     * number of all vertixes p - array with indexes of all parent vertix for
     * each other d - array with distance from start vertix to each other [if g
     * - zvazhenii, d[to] = d[v] + weigth of edge]
     *
     * В результате поиска в ширину находится путь кратчайшей длины в
     * невзвешененном графе, т.е. путь, содержащий наименьшее число рёбер.
     * Алгоритм работает за , где — число вершин, — число рёбер.
     *
     * if (!used[to]) System.out.println("No path!"); else { ArrayList <Integer>
     * path = new ArrayList<Integer>(); for (int v = to; v != -1; v = p[v]) {
     * path.add(v); } reverse (path.begin(), path.end());
     * System.out.println("Path:") for (int i = 0; i < path.size(); ++i) {
     * System.out.println(path[i] + 1); } }
     ****/
    public static void bfs(int s, ArrayList<Integer>[] g) {
        int n = g.length;
        Queue<Integer> q = new LinkedList<Integer>();
        q.add(s);
        boolean[] used = new boolean[n];
        int[] d = new int[n];
        int[] p = new int[n];
        used[s] = true;
        p[s] = -1;
        while (!q.isEmpty()) {
            int v = q.poll();
            for (int i = 0; i < g[v].size(); ++i) {
                int to = g[v].get(i);
                if (!used[to]) {
                    used[to] = true;
                    q.add(to);
                    d[to] = d[v] + 1;
                    p[to] = v;
                }
            }
        }
    }

    /****
     * g - graph as list sumiznosti v - number of vertix from dfs calls n -
     * number of all vertixes used - array which shows be or not visited vertix
     *
     * В результате поиска в глубину находится лексикографически первый путь в
     * графе. Алгоритм работает за O (N+M).
     *
     *
     ****/
    static int n = 100500;  // вершин
    static int m = 100500;  // ребер
    static ArrayList<Integer>[] g = new ArrayList[n];
    static boolean[] used = new boolean[g.length];

    public static void dfs(int v) {
        used[v] = true;
        for (int i = 0; i < g[v].size(); i++) {
            int to = g[v].get(i);
            if (!used[to]) {
                dfs(to);
            }
        }
    }

    /****
     * g - graph as list sumiznosti n - number of all vertixes used - array
     * which shows be or not visited vertix
     *
     * ans - список із відсорченими вершинами
     *
     * Дан ориентированный граф с вершинами и рёбрами. Требуется перенумеровать
     * его вершины таким образом, чтобы каждое рёбро вело из вершины с меньшим
     * номером в вершину с большим. Иными словами, требуется найти перестановку
     * вершин (топологический порядок), соответствующую порядку, задаваемому
     * всеми рёбрами графа.
     *
     ****/
    static ArrayList<Integer> ans = new ArrayList<Integer>();

    public static void topologicalSort() {
        for (int i = 0; i < n; ++i)
            used[i] = false;
        ans.clear();
        for (int i = 0; i < n; ++i)
            if (!used[i])
                dfs(i);
        Collections.reverse(ans);
    }

    class Pair {
        int first;
        int second;
        public Pair(int to, int len) {
            first = to;
            second = len;
        }
    }

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

    /**
     * O(n^2 + m)
     * Дан ориентированный или неориентированный взвешенный граф с n вершинами и m рёбрами.
     * Веса всех рёбер неотрицательны. Указана некоторая стартовая вершина s.
     * Требуется найти длины кратчайших путей из вершины s во все остальные вершины,
     * а также предоставить способ вывода самих кратчайших путей.
     *
     * После выполнения всех итераций в массиве d[] оказываются длины кратчайших путей до всех вершин,
     * а в массиве p[] — предки всех вершин (кроме стартовой s). Восстановить путь до любой вершины t можно следующим образом:
     *
     * vector<int> path;
     * for (int v=t; v!=s; v=p[v])
     *  path.push_back (v);
     *  path.push_back (s);
     *  reverse (path.begin(), path.end());
     */
    public static void Dejkstra(int s, ArrayList<Pair>[] g) {
        int[]d = new int[n];
        int[]p = new int[n];
        Arrays.fill(d, INF);
        d[s] = 0;
        boolean[]u = new boolean[n];
        for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                if (!u[j] && (v == -1 || d[j] < d[v]))
                    v = j;
            if (d[v] == INF)
                break;
            u[v] = true;

            for (int j=0; j<g[v].size(); ++j) {
                int to = g[v].get(j).first,
                    len = g[v].get(j).second;
                if (d[v] + len < d[to]) {
                    d[to] = d[v] + len;
                    p[to] = v;
                }
            }
        }
    }

    /**
     * O(N*M)
     * Пусть дан ориентированный взвешенный граф G с n вершинами и m рёбрами,
     * и указана некоторая вершина v. Требуется найти длины кратчайших путей от вершины v до всех остальных вершин.
     *
     * В отличие от алгоритма Дейкстры, этот алгоритм применим также и к графам, содержащим рёбра отрицательного веса.
     * Впрочем, если граф содержит отрицательный цикл, то, понятно, кратчайшего пути до некоторых вершин может
     * не существовать (по причине того, что вес кратчайшего пути должен быть равен минус бесконечности);
     * впрочем, этот алгоритм можно модифицировать, чтобы он сигнализировал о наличии цикла отрицательного веса,
     * или даже выводил сам этот цикл.
     *
     * Заведём массив расстояний d[], который после отработки алгоритма будет содержать ответ на задачу.
     *
     * if (d[t] == INF)
     *      cout << "No path from " << v << " to " << t << ".";
     *  else {
     *      vector<int> path;
     *      for (int cur=t; cur!=-1; cur=p[cur])
     *          path.push_back (cur);
     *      reverse (path.begin(), path.end());
     *      cout << "Path from " << v << " to " << t << ": ";
     *      for (size_t i=0; i<path.size(); ++i)
     *          cout << path[i] << ' ';
     * }
     */
    public static void FordBellman(int v, ArrayList <Edge> e) {
        int[]d = new int[n];
        int[]p = new int[n];

        Arrays.fill(d, INF);
        Arrays.fill(p, -1);

        d[v] = 0;
        for (;;) {
            boolean any = false;
            for (int j=0; j<m; ++j)
                if (d[e.get(j).a] < INF)
                    if (d[e.get(j).b] > d[e.get(j).a] + e.get(j).cost) {
                        d[e.get(j).b] = d[e.get(j).a] + e.get(j).cost;
                        p[e.get(j).b] = e.get(j).a;

                        any = true;
                    }
            if (!any)  break;
        }
    }

    /**
     * O(N^3)
     * Дан ориентированный или неориентированный взвешенный граф G с n вершинами.
     * Требуется найти значения всех величин dij — длины кратчайшего пути из вершины i в вершину j.
     *
     * На вход программе подаётся граф, заданный в виде матрицы смежности — двумерного массива d[][] размера n*n,
     * в котором каждый элемент задаёт длину ребра между соответствующими вершинами.
     * Требуется, чтобы выполнялось d[i][i] = 0 для любых i.
     */
    public static void FloydWorshall(int[][]d) {
        for (int k=0; k<n; ++k)
            for (int i=0; i<n; ++i)
                for (int j=0; j<n; ++j)
                    if (d[i][k] < INF && d[k][j] < INF)
                        d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
    }

    /**
     * O(n^2)
     *
     * Дан взвешенный неориентированный граф G с n вершинами и m рёбрами.
     * Требуется найти такое поддерево этого графа, которое бы соединяло все его вершины,
     * и при этом обладало наименьшим возможным весом (т.е. суммой весов рёбер).
     * Поддерево — это набор рёбер, соединяющих все вершины, причём из любой вершины можно
     * добраться до любой другой ровно одним простым путём.
     *
     * Такое поддерево называется минимальным остовным деревом или просто минимальным остовом.
     * Легко понять, что любой остов обязательно будет содержать n - 1 ребро.
     * В естественной постановке эта задача звучит следующим образом: есть n городов, и для каждой
     * пары известна стоимость соединения их дорогой (либо известно, что соединить их нельзя).
     * Требуется соединить все города так, чтобы можно было доехать из любого города в другой,
     * а при этом стоимость прокладки дорог была бы минимальной.
     *
     *
     * На вход подаются число вершин n и матрица g[][] размера n*n,
     * в которой отмечены веса рёбер, и стоят числа INF, если соответствующее ребро отсутствует.
     * Алгоритм поддерживает три массива: флаг used[i] = true означает, что вершина i включена в остов,
     * величина min_e[i] хранит вес наименьшего допустимого ребра из вершины i,
     * а элемент sel_e[i] содержит конец этого наименьшего ребра (это нужно для вывода рёбер в ответе).
     * Алгоритм делает n шагов, на каждом из которых выбирает вершину v с наименьшей меткой min_e, помечает её used,
     * и затем просматривает все рёбра из этой вершины, пересчитывая их метки.   *
     */
    public static void Prima(int g[][]) {
        boolean[]used = new boolean[n];
        int[]min_e = new int[n];
        int[]sel_e = new int[n];
        Arrays.fill(min_e, INF);
        Arrays.fill(sel_e, -1);

        min_e[0] = 0;
        for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                if (!used[j] && (v == -1 || min_e[j] < min_e[v]))
                    v = j;
            if (min_e[v] == INF) {
                System.out.println("No MST!");
                return;
            }

            used[v] = true;
            if (sel_e[v] != -1)
                System.out.println(v + " " + sel_e[v]);

            for (int to=0; to<n; ++to)
                if (g[v][to] < min_e[to]) {
                    min_e[to] = g[v][to];
                    sel_e[to] = v;
                }
        }
    }

    static int[]cl;
    static int[]p;
    static int cycle_st;
    static int cycle_end;

    /**
     * O(M)
     * Пусть дан ориентированный или неориентированный граф без петель и кратных рёбер.
     * Требуется проверить, является ли он ациклическим, а если не является, то найти любой цикл.
     */

    public static void FindCircle(ArrayList<Integer>[] g) {
        p = new int[n];
        Arrays.fill(p, -1);
        cl = new int[n];
        cycle_st = -1;
        for (int i=0; i<n; ++i)
            if (dfsForCircle(i, g))
                break;

        if (cycle_st == -1)
            System.out.println("Acyclic");
        else {
            System.out.println("Cyclic");
            ArrayList<Integer>cycle = new ArrayList<Integer>();;
            cycle.add(cycle_st);
            for (int v=cycle_end; v!=cycle_st; v=p[v])
                cycle.add(v);
            cycle.add(cycle_st);
            Collections.reverse(cycle);
            for (int i=0; i<cycle.size(); ++i)
                System.out.println(cycle.get(i)+1);
        }
    }

    public static boolean dfsForCircle (int v, ArrayList<Integer>[] g) {
        cl[v] = 1;
        for (int i=0; i<g[v].size(); ++i) {
            int to = g[v].get(i);
            if (cl[to] == 0) {
                p[to] = v;
                if (dfsForCircle (to, g))  return true;
            }
            else if (cl[to] == 1) {
                cycle_end = v;
                cycle_st = to;
                return true;
            }
        }
        cl[v] = 2;
        return false;
    }
}

class StringUtil {

    /**
     * Пусть дана строка s длины n. Тогда Z-функция от этой строки — это массив длины n, i-ый элемент
     * которого равен наибольшему числу символов, начиная с позиции i, совпадающих с первыми символами строки s.
     * Иными словами, z[i] — это наибольший общий префикс строки s и её i-го суффикса.
     *
     * Example:
     * "aaabaab"
     * z[0] = 0
     * z[1] = 2
     * z[2] = 1
     * z[3] = 0
     * z[4] = 2
     * z[5] = 1
     * z[6] = 0
     */
    public static int[] zFunction (String s) {
        int n = s.length();
        int[]z = new int[n];
        for (int i=1, l=0, r=0; i<n; ++i) {
            if (i <= r)
                z[i] = Math.min(r-i+1, z[i-l]);
            while (i+z[i] < n && s.charAt(z[i]) == s.charAt(i+z[i]))
                ++z[i];
            if (i+z[i]-1 > r) {
                l = i;
                r = i+z[i]-1;
            }
        }
        return z;
    }

    public static int[] prefixFunction(String s) {
        int n = s.length();
        int[] p = new int[n];
        for (int i = 1; i < n; i++) {
            int k = p[i - 1];
            while (k > 0 && s.charAt(k) != s.charAt(i)) {
                k = p[k - 1];
            }
            p[i] = k + (s.charAt(k) == s.charAt(i) ? 1 : 0);
        }
        return p;
    }

    /**
     * s - текст в якому шукаєм
     * pattern - слово яке шукаємо
     * Повертає -1 якщо немає входження, або індекс входження
     */
    public static int kmpMatcher(String s, String pattern) {
        int m = pattern.length();
        if (m == 0) {
            return 0;
        }
        int n = s.length();
        int[] p = prefixFunction(pattern);
        int k = 0;
        for (int i = 0; i < n; i++) {
            while (k > 0 && s.charAt(i) != pattern.charAt(k)) {
                k = p[k - 1];
            }
            if (s.charAt(i) == pattern.charAt(k)) {
                k++;
            }
            if (k == m) {
                return i - m + 1;
            }
        }
        return -1;
    }

    /**
     * Дана строка S и текст T, состоящие из маленьких латинских букв.
     * Требуется найти все вхождения строки S в текст T за время O (|S| + |T|).
     * Алгоритм. Посчитаем хэш для строки S. Посчитаем значения хэшей для всех префиксов строки T.
     * Теперь переберём все подстроки T длины |S| и каждую сравним с |S| за время O (1).
     */
    public static ArrayList<Integer> RabinKarp(String s, String t) {
        ArrayList<Integer>indexes = new ArrayList<Integer>();
        final int p = 31;
        long[]p_pow = new long[Math.max(s.length(), t.length())];
        p_pow[0] = 1;
        for (int i=1; i<p_pow.length; ++i)
            p_pow[i] = p_pow[i-1] * p;

        long[]h = new long[(t.length())];
        for (int i=0; i<t.length(); ++i)
        {
            h[i] = (t.charAt(i) - 'a' + 1) * p_pow[i];
            if (i!=0)  h[i] += h[i-1];
        }

        long h_s = 0;
        for (int i=0; i<s.length(); ++i)
            h_s += (s.charAt(i) - 'a' + 1) * p_pow[i];

        for (int i = 0; i + s.length() - 1 < t.length(); ++i)
        {
            long cur_h = h[i+s.length()-1];
            if (i!=0)  cur_h -= h[i-1];
            if (cur_h == h_s * p_pow[i])
                indexes.add(i);
        }
        return indexes;
    }

    public static void palindromsCount(String s) {
        int n = s.length();
        int[]d1 = new int[n];
        int l=0, r=-1;
        for (int i=0; i<n; ++i) {
            int k = (i>r ? 0 : Math.min (d1[l+r-i], r-i)) + 1;
            while (i+k < n && i-k >= 0 && s.charAt(i+k) == s.charAt(i-k))  ++k;
            d1[i] = k--;
            if (i+k > r) {
                l = i-k;
                r = i+k;
            }
        }

        int[]d2 = new int[n];
        l=0;
        r=-1;
        for (int i=0; i<n; ++i) {
            int k = (i>r ? 0 : Math.min (d2[l+r-i+1], r-i+1)) + 1;
            while (i+k-1 < n && i-k >= 0 && s.charAt(i+k-1) == s.charAt(i-k))  ++k;
            d2[i] = --k;
            if (i+k-1 > r) {
                l = i-k;
                r = i+k-1;
            }
        }
    }
}

class Combinatorica {
    /**
     * Перестановка з n - елементів
     * P = n!
     */
    public static long P(int n) {
        long ans = 1;
        if (n == 0) return 0;
        while (n > 0) {
            ans *= n;
            n--;
        }
        return ans;
    }

    /**
     * Кількість можливих m - елементних множин з множини з n елементів.
     * С(m, n) = n! / (m! * (n - m)!)   m <= n
     */
    public static long C(int m, int n) {
        if (m == 0 || m == n) return 1;
        long a = Combinatorica.P(n);
        long b = Combinatorica.P(m);
        long c = Combinatorica.P(n - m);
        return a / b / c;
    }

    /**
     * Кількість різних комбінацій із n елементів по m елементів з повтореннями становить
     * C(n - 1, n + m - 1) = C(m, n + m - 1)
     */
    public static long CwithRepeat(int n, int m) {
        return C(n - 1, n + m - 1);
    }

    /**
     * Кількість упорядкованих m-елементних підмножин n-елементної множини, всі m елементів якої різні
     */
    public static long A(int m, int n) {
        return Combinatorica.P(n) / Combinatorica.P(n - m);
    }
 }

class Matrix {
    /**
     * Додати дві матриці
     * @param a - матриця1
     * @param b - матриця2
     * @return нова матриця (а + б)
     */
    public static long[][] matrixAdd(long[][] a, long[][] b) {
        int n = a.length;
        int m = a[0].length;
        long[][] res = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                res[i][j] = a[i][j] + b[i][j];
            }
        }
        return res;
    }

    /**
     * Множення двох матриць
     * @param a - матриця1
     * @param b - матриця2
     * @return нова матриця (а * б)
     */
    public static long[][] matrixMul(long[][] a, long[][] b) {
        int n = a.length;
        int m = a[0].length;
        int k = b[0].length;
        long[][] res = new long[n][k];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < k; j++) {
                for (int p = 0; p < m; p++) {
                    res[i][j] = res[i][j] + a[i][p] * b[p][j];
                }
            }
        }
        return res;
    }

    /**
     * Піднести матрицю до степеня P
     * @param a - матриця
     * @param P - степінь
     * @return нова матриця a^P
     */
    public static long[][] matrixPow(long[][] a, long p) {
        if (p == 0) {
            return matrixUnit(a.length);
        } else if (p % 2 == 0) {
            return matrixPow(matrixMul(a, a), p / 2);
        } else {
            return matrixMul(a, matrixPow(a, p - 1));
        }
    }

    public static long[][] matrixPowSum(long[][] a, long p) {
        int n = a.length;
        if (p == 0) {
            return new long[n][n];
        }
        if (p % 2 == 0) {
            return matrixMul(matrixPowSum(a, p / 2),
                    matrixAdd(matrixUnit(n), matrixPow(a, p / 2)));
        } else {
            return matrixAdd(a, matrixMul(matrixPowSum(a, p - 1), a));
        }
    }

    /**
     * Cтворення одиничної матриці розміром n*n
     * @param n
     * @return матриця заповнена одиницями.
     */
    public static long[][] matrixUnit(int n) {
        long[][] res = new long[n][n];
        for (int i = 0; i < n; ++i) {
            res[i][i] = 1;
        }
        return res;
    }
}

class IO_Type {

    public static String CONSOLE = "console";
    public static String FILE = "file";

}

class BigIntegerUtil {
    public static BigInteger pow(BigInteger a, int exponent) {
        return a.pow(exponent);
    }
    public static BigInteger subtract(BigInteger a, BigInteger b) {
        return a.subtract(b);
    }
    public static BigInteger add(BigInteger a, BigInteger b) {
        return a.add(b);
    }
    public static BigInteger multiply(BigInteger a, BigInteger b) {
        return a.multiply(b);
    }
    public static BigInteger divide(BigInteger a, BigInteger b) {
        return a.divide(b);
    }
}

class FastScanner {

    BufferedReader br;
    StringTokenizer st;

    FastScanner getScanner() {
        return this;
    }

    FastScanner(String type) {
        if (type.equals("console")) {
            FastScanner(System.in);
        }
    }

    FastScanner(String type, String inFileName) {
        if (type.equals("file")) {
            File f = new File(inFileName);
            try {
                FastScanner(new FileInputStream(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    void FastScanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
    }

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                System.err.println(e);
                return "";
            }
        }
        return st.nextToken();
    }

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

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

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

    float nextFloat() {
        return Float.parseFloat(next());
    }

    BigInteger nextBigInt() {
        return new BigInteger(next());
    }

    void close() {
        try {
            br.close();
        } catch (IOException e) {
        }
    }
}

class FastWriter {

    PrintWriter pw;

    PrintWriter getWriter() {
        return pw;
    }

    FastWriter(String type) {
        FastWriter(type);
    }

    FastWriter(String type, String outFileName) {
        FastWriter(type, outFileName);
    }

    PrintWriter FastWriter(String type) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        return pw;
    }

    PrintWriter FastWriter(String type, String outFileName) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        else if (type.equals("file")) {
            try {
                pw = new PrintWriter(new File(outFileName));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        return pw;
    }
}

/***
*   Help:
*   https://sites.google.com/site/indy256/algo/
*   http://e-maxx.ru/algo/
*/

import java.util.Scanner;

public class random {
	public static void main (String[] args) {
		Scanner s = new Scanner(System.in);
		int num = s.nextInt();
		int[][] array = new int[num][num];

		for (int x = 0; x < num; x ++) {
			for (int y = 0; y < num; y ++) {
				int n = s.nextInt();
				array[x][y] = n;
			}
		}

		int sum = 0;
		for (int x = 0; x < num; x ++) {
			sum += array[x][x];
			sum += array[num - 1 - x][num - 1 - x];
			sum += array[x][num/2];
			sum += array[num/2][x];
		}
		sum -= 3*(array[num/2][num/2]);
		System.out.println(sum);
	}
}

import java.util.Scanner;

public class random {
	public static void main (String[] args) {
		Scanner s = new Scanner(System.in);
		int num = s.nextInt();
		int[][] array = new int[num][num];

		for (int x = 0; x < num; x ++) {
			for (int y = 0; y < num; y ++) {
				int n = s.nextInt();
				array[x][y] = n;
			}
		}

		int sum = 0;
		for (int x = 0; x < num; x ++) {
			sum += array[x][x];
			sum += array[num - 1 - x][num - 1 - x];
			sum += array[x][num/2];
			sum += array[num/2][x];
		}
		System.out.println(sum);
	}
}

import java.util.HashSet;
import java.util.Scanner;

public class A177_1 {
    public static void main(String q[]){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int ar[][]=new int[n][n];
        long sum=0;
        HashSet<String> visited=new HashSet<String>();
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
                ar[i][j]=sc.nextInt();
        //main diagonal
        for (int i=0;i<n;i++){
            String pos=""+i+i;
            if(!visited.contains(pos)){
                visited.add(pos);
                sum+=ar[i][i];
            }
        }
        //secondary diagonal
        for (int i=0;i<n;i++){
            int j=n-i-1;
            String pos=""+i+j;
            if(!visited.contains(pos)){
                visited.add(pos);
                sum+=ar[i][j];
            }
        }
        //mid column
        for (int i=0;i<n;i++){
            int j=n/2;
            String pos=""+i+j;
            if(!visited.contains(pos)){
                visited.add(pos);
                sum+=ar[i][j];
            }
        }
        //mid row
        for (int i=0;i<n;i++){
            int j=n/2;
            String pos=""+j+i;
            if(!visited.contains(pos)){
                visited.add(pos);
                sum+=ar[j][i];
            }
        }
        System.out.println(sum);
    }
}

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

public class A1_177 {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(in.readLine());
		int[][] p = new int[n][n];
		for(int i = 0;i<n;i++) {
			String[] temp = in.readLine().split(" ");
			for(int j = 0;j<temp.length;j++) {
				p[i][j] = Integer.parseInt(temp[j]);
			}
		}
		int c  = 0;
		for(int i = 0;i<n;i++) {
			for(int j = 0;j<n;j++) {
				if(i == j) {
					c += p[i][j];
//					System.out.print(p[i][j] + " ");
				} else if(i == n - j - 1) {
					c += p[i][n - j - 1];
//					System.out.print(p[i][j] + " ");

				} else if(i == n / 2) {
					c += p[i][j];
//					System.out.print(p[i][j] + " ");

				} else if(j == n / 2) {
					c += p[i][j];
//					System.out.print(p[i][j] + " ");

				}
			}
		}
		System.out.println(c);
	}
}

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

public class A1_177 {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(in.readLine());
		int[][] p = new int[n][n];
		for(int i = 0;i<n;i++) {
			String[] temp = in.readLine().split(" ");
			for(int j = 0;j<temp.length;j++) {
				p[i][j] = Integer.parseInt(temp[j]);
			}
		}
		int c  = 0;
		for(int i = 0;i<n;i++) {
			for(int j = 0;j<n;j++) {
				if(i == j) {
					c += p[i][j];
					System.out.print(p[i][j] + " ");
				} else if(i == n - j - 1) {
					c += p[i][n - j - 1];
					System.out.print(p[i][j] + " ");

				} else if(i == n / 2) {
					c += p[i][j];
					System.out.print(p[i][j] + " ");

				} else if(j == n / 2) {
					c += p[i][j];
					System.out.print(p[i][j] + " ");

				}
			}
		}
		System.out.println(c);
	}
}

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

public class Main implements Runnable {

	public void solve() throws IOException {
		int N = nextInt();
                int[][] a = new int[N][N];
                for(int i = 0; i < N; i++){
                        for(int j = 0; j < N; j++) a[i][j] = nextInt();
                }

                int ans = 0;
                for(int i = 0; i < N; i++) ans += a[i][i];
                for(int i = 0; i < N; i++) ans += a[N - i - 1][N - i - 1];
                for(int i = 0; i < N; i++) ans += a[N/2][i];
                for(int i = 0; i < N; i++) ans += a[i][N/2];

                ans -= 3 * a[N/2][N/2];

                System.out.println(ans);
	}

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

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

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

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

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

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

	BufferedReader in;
	StringTokenizer tok;
}

import java.util.Scanner;

public class cp101Code3 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int ld = 0;
        int rd = 0;
        int mc = 0;
        int mr = 0;

        int j = n - 1;
        int m = (n - 1) / 2;
        for (int i = 0; i < n; i++) {
            ld += arr[i][i];
            rd += arr[i][j];
            j -= 1;
        }
        for (int r = 0; r < n; r++) {
            if (r == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[r][k];
                }
            }
        }
        for (int c = 0; c < n; c++) {
            if (c == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[c][k];
                }
            }
        }
        System.out.println((mr + mc + ld + rd) - (3 * arr[m][m]));
    }
}

import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author katha
 */
public class cp101Code3 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int ld = 0;
        int rd = 0;
        int mr = 0;
        int mc = 0;
        int j = n - 1;
        int m = (n - 1) / 2;
        for (int i = 0; i < n; i++) {
            ld += arr[i][i];
            rd += arr[i][j];
            j -= 1;
            if (i == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[i][k];
                }
            }
            if (j == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mc += arr[k][j];
                }
            }
        }
        System.out.println((mr + mc + ld + rd) - (3 * arr[m][m]));
    }
}

import java.util.Scanner;

public class cp101Code3 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int ld = 0;
        int rd = 0;
        int mc = 0;
        int mr = 0;

        int j = n - 1;
        int m = (n - 1) / 2;
        for (int i = 0; i < n; i++) {
            ld += arr[i][i];
            rd += arr[i][j];
            j -= 1;
            if (i == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[i][k];
                }
            }
        }
        for(int i = 0; i< n; i++){
        if (i == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[i][k];
                }
            }
        }
        System.out.println((mr + mc + ld + rd) - (3 * arr[m][m]));
    }
}

import java.util.Scanner;

public class cp101Code3 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int d = 0;
        int mc = 0;
        int mr = 0;

        int j = n - 1;
        int m = (n - 1) / 2;
        for (int i = 0; i < n; i++) {
            d += arr[i][i] + arr[i][j];
            j -= 1;
        }
        for (int r = 0; r < n; r++) {
            if (r == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[r][k];
                }
            }
        }
        for (int c = 0; c < n; c++) {
            if (c == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[c][k];
                }
            }
        }
        System.out.println((mr + mc + d) - (3 * arr[m][m]));
    }
}

import java.util.Scanner;

public class cp101Code3 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        int ld = 0;
        int rd = 0;
        int mr = 0;
        int mc = 0;
        int j = n - 1;
        int m = (n - 1) / 2;
        for (int i = 0; i < n; i++) {
            ld += arr[i][i];
            rd += arr[i][j];
            j -= 1;
            if (i == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mr += arr[i][k];
                }
            }
            if (j == (n - 1) / 2) {
                for (int k = 0; k < n; k++) {
                    mc += arr[k][j];
                }
            }
        }
        System.out.println((mr + mc + ld + rd) - (3 * arr[m][m]));
    }
}