Magnus decided to play a classic chess game. Though what he saw in his locker shocked him! His favourite chessboard got broken into 4 pieces, each of size n by n, n is always odd. And what's even worse, some squares were of wrong color. j-th square of the i-th row of k-th piece of the board has color ak, i, j; 1 being black and 0 being white. 

Now Magnus wants to change color of some squares in such a way that he recolors minimum number of squares and obtained pieces form a valid chessboard. Every square has its color different to each of the neightbouring by side squares in a valid board. Its size should be 2n by 2n. You are allowed to move pieces but not allowed to rotate or flip them.

Input

The first line contains odd integer n (1 ≤ n ≤ 100) — the size of all pieces of the board. 

Then 4 segments follow, each describes one piece of the board. Each consists of n lines of n characters; j-th one of i-th line is equal to 1 if the square is black initially and 0 otherwise. Segments are separated by an empty line.

Output

Print one number — minimum number of squares Magnus should recolor to be able to obtain a valid chessboard.

Examples

Input

1
0

0

1

0


Output

1


Input

3
101
010
101

101
000
101

010
101
011

010
101
010


Output

2
import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
import java.math.BigInteger;
import java.util.regex.*;
public class Myclass {
		public static ArrayList a[]=new ArrayList[200001];
		/*static boolean visited[]=new boolean [200001];
		static int parent[]=new int[200001];
		static int color[]=new int[200001];
		static long ans;
		static void bfs()
		{
			Queue<Integer>q=new LinkedList<>();
			q.add(1);
			color[1]=1;
			parent[1]=0;
			color[0]=1;
			ans=1;
			while(!q.isEmpty())
			{
				int idx=q.poll();
				visited[idx]=true;
				int cnt=1;
				TreeSet<Integer>tr=new TreeSet<>();
				tr.add(color[idx]);
				tr.add(color[parent[idx]]);
				for(int i=0;i<a[idx].size();i++)
				{
					int id=(int) a[idx].get(i);
					if(!visited[id])
					{
						while(tr.contains(cnt))
							cnt++;
						parent[id]=idx;
						color[id]=cnt;
						ans=Math.max(ans, color[id]);
						cnt++;
						q.add(id);
					}
				}
			}
		}*/
		static char s[][][];
		static int ans[][]=new int[4][2];
		static int n;
		static int f(int idx)
		{
			int cnt=0;
			for(int i=0;i<n;i++)
			{
				for(int j=0;j<n;j++)
				{
					if(i%2==0)
					{
						if(j%2==0)
						{
							if(s[idx][i][j]!='1')
								cnt++;
						}
						else
						{
							if(s[idx][i][j]!='0')
								cnt++;
						}
					}
					else
					{
						if(j%2==0)
						{
							if(s[idx][i][j]!='0')
								cnt++;
						}
						else
						{
							if(s[idx][i][j]!='1')
								cnt++;
						}
					}
				}
			}
			return cnt;
		}
		static int f1(int idx)
		{
			int cnt=0;
			for(int i=0;i<n;i++)
			{
				for(int j=0;j<n;j++)
				{
					if(i%2==0)
					{
						if(j%2==0)
						{
							if(s[idx][i][j]!='0')
								cnt++;
						}
						else
						{
							if(s[idx][i][j]!='1')
								cnt++;
						}
					}
					else
					{
						if(j%2==0)
						{
							if(s[idx][i][j]!='1')
								cnt++;
						}
						else
						{
							if(s[idx][i][j]!='0')
								cnt++;
						}
					}
				}
			}
			return cnt;
		}
		public static void main(String[] args) 
		{
		    InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);
			n=in.nextInt();
			s=new char[4][n][n];
			for(int i=0;i<4;i++)
			{
				for(int j=0;j<n;j++)
				{
					s[i][j]=in.nextLine().toCharArray();
				}
			}
			ans[0][0]=f(0);
			ans[1][0]=f(1);
			ans[2][0]=f(2);
			ans[3][0]=f(3);
			ans[0][1]=f1(0);
			ans[1][1]=f1(1);
			ans[2][1]=f1(2);
			ans[3][1]=f1(3);
			long fi=Long.MAX_VALUE;
			fi=Math.min(fi, ans[0][0]+ans[1][0]+ans[2][1]+ans[3][1]);
			fi=Math.min(fi, ans[0][0]+ans[1][1]+ans[2][0]+ans[3][1]);
			fi=Math.min(fi, ans[0][0]+ans[1][1]+ans[2][1]+ans[3][0]);
			fi=Math.min(fi, ans[0][1]+ans[1][0]+ans[2][0]+ans[3][1]);
			fi=Math.min(fi, ans[0][1]+ans[1][0]+ans[2][1]+ans[3][0]);
			fi=Math.min(fi, ans[0][1]+ans[1][1]+ans[2][0]+ans[3][0]);
			pw.println(fi);
			pw.flush();
			pw.close();
		}
		
		static class InputReader 
		{
		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;
 
		public InputReader(InputStream stream) 
		{
			this.stream = stream;
		}
		public int snext() 
		{
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) 
			{
				curChar = 0;
				try 
				{
					snumChars = stream.read(buf);
				} 
				catch (IOException e) 
				{
					throw new InputMismatchException();
				}
				
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
 
		public int nextInt() 
	    {
			int c = snext();
			while (isSpaceChar(c)) 
			{
				c = snext();
			}
			int sgn = 1;
			if (c == '-')
		    {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public long nextLong()
	    {
			int c = snext();
			while (isSpaceChar(c)) 
			{
				c = snext();
			}
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public int[] nextIntArray(int n) 
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++) 
			{
				a[i] = nextInt();
			}
			return a;
		}
		static class tri implements Comparable<tri> {
			int p, c, l;
 
			tri(int p, int c, int l) {
				this.p = p;
				this.c = c;
				this.l = l;
			}
 
			public int compareTo(tri o) {
				return Integer.compare(l, o.l);
			}
		}
 
		public String readString()
	    {
			int c = snext();
			while (isSpaceChar(c)) 
			{
				c = snext();
			}
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}
 
		public String nextLine() 
		{
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(c));
			return res.toString();
		}
 
		public boolean isSpaceChar(int c) 
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
 
		private boolean isEndOfLine(int c) 
		{
			return c == '\n' || c == '\r' || c == -1;
		}
 
		public interface SpaceCharFilter
	    {
			public boolean isSpaceChar(int ch);
		}
	}
		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;
		
		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}
		
		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}
		
		public static HashSet<Integer> primeFactorization(int n)
		{
			HashSet<Integer> a =new HashSet<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}
		
		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;
			
			isPrime[0] = false;
			isPrime[1] = false;
			
			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}
		
		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}
		
		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}
		
		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}
		
		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}
		
		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}
		
		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}
		
		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}
		
		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x%M*x)%M;
		        n=n/2;
		    }
		    return result;
		}
		
		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result%M * x%M)%M;
		        x=(x%M * x%M)%M;
		        n=n/2;
		    }
		    return result;
		}
		
		public static long modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}
		
		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}
		
		public static boolean isPrime(int n)
		{
		    
		    if (n <= 1)  return false;
		    if (n <= 3)  return true;
		    
		    if (n%2 == 0 || n%3 == 0) 
		    	return false;
		 
		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }
		    
		    return true;
		}
		
		 public static long[] shuffle(long[] a, Random gen){ 
		        for(int i = 0, n = a.length;i < n;i++){ 
		            int ind = gen.nextInt(n-i)+i; 
		            long d = a[i]; 
		            a[i] = a[ind]; 
		            a[ind] = d; 
		        } 
		        return a; 
		    }
		static class pair implements Comparable<pair>
		{
			Long x;
			Long y;
			pair(long a,long m)
			{
				this.x=a;
				this.y=m;
			}
			
 
			
 
 
		public boolean isEmpty() {
				// TODO Auto-generated method stub
				return false;
			}
 
 
 
 
 
		public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);
				
			return result;
			}  
			
			public String toString()
			{
				return x+" "+y;
			}
			
			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}
			
			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}
}
