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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Stack;
								
									 
								public    class Main implements Runnable
									{
										static final int MAX = 1000000007;
										static class InputReader
										{
											private InputStream stream;
											private byte[] buf = new byte[1024];
											private int curChar;
											private int numChars;
											private SpaceCharFilter filter;
											private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
									
											public InputReader(InputStream stream)
											{
												this.stream = stream;
											}
											
											public int read()
											{
												if (numChars==-1) 
													throw new InputMismatchException();
												
												if (curChar >= numChars)
												{
													curChar = 0;
													try 
													{
														numChars = stream.read(buf);
													}
													catch (IOException e)
													{
														throw new InputMismatchException();
													}
													
													if(numChars <= 0)				
														return -1;
												}
												return buf[curChar++];
											}
										 
											public String nextLine()
											{
												String str = "";
									            try
									            {
									                str = br.readLine();
									            }
									            catch (IOException e)
									            {
									                e.printStackTrace();
									            }
									            return str;
											}
											public int nextInt()
											{
												int c = read();
												
												while(isSpaceChar(c)) 
													c = read();
												
												int sgn = 1;
												
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												
												int res = 0;
												do 
												{
													if(c<'0'||c>'9') 
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												while (!isSpaceChar(c)); 
												
												return res * sgn;
											}
											
											public long nextLong() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												long res = 0;
												
												do 
												{
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												while (!isSpaceChar(c));
													return res * sgn;
											}
											
											public double nextDouble() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												double res = 0;
												while (!isSpaceChar(c) && c != '.') 
												{
													if (c == 'e' || c == 'E')
														return res * Math.pow(10, nextInt());
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												if (c == '.') 
												{
													c = read();
													double m = 1;
													while (!isSpaceChar(c)) 
													{
														if (c == 'e' || c == 'E')
															return res * Math.pow(10, nextInt());
														if (c < '0' || c > '9')
															throw new InputMismatchException();
														m /= 10;
														res += (c - '0') * m;
														c = read();
													}
												}
												return res * sgn;
											}
											
											public String readString() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												StringBuilder res = new StringBuilder();
												do 
												{
													res.appendCodePoint(c);
													c = read();
												} 
												while (!isSpaceChar(c));
												
												return res.toString();
											}
										 
											public boolean isSpaceChar(int c) 
											{
												if (filter != null)
													return filter.isSpaceChar(c);
												return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
											}
										 
											public String next() 
											{
												return readString();
											}
											
											public interface SpaceCharFilter 
											{
												public boolean isSpaceChar(int ch);
											}
											public boolean ready(){
												try {
													return br.ready();
												} catch (IOException e) {
													return false;
												}
											}
										}
									 	
										public static void main(String args[]) throws Exception
										{
											new Thread(null, new Main(),"Main",1<<26).start();
										}
										public void run()
										{	
											InputReader sc= new InputReader(System.in);
											PrintWriter w= new PrintWriter(System.out);
											int n = sc.nextInt();
											int[][][] arr = new int[4][n][n];
											
											for(int i = 0;i < 4;i++){
												for(int j = 0;j < n;j++){
													String s=  sc.next();
													for(int k = 0;k < n;k++){
														arr[i][j][k] = s.charAt(k)-48;
														//w.print(arr[i][j][k] + " ");
													}
												}
												
												w.println();
												
											}
											int ans = Integer.MAX_VALUE;
											for(int i = 0;i <= 3;i++){
												for(int l = i+1;l <= 3;l++){
													int[][] make = new int[n][n];
													int[][] make2 = new int[n][n];
													for(int j = 0;j < n;j++){
														for(int k = 0;k < n;k++){
															if(j == 0 && k == 0){
																make[j][k] = 0;
															}else if(k == 0){
																make[j][k] = make[j-1][k] ^ 1; 
															}else{
																make[j][k] = make[j][k-1] ^ 1;
															}
														}
													}
													for(int j = 0;j < n;j++){
														for(int k = 0;k < n;k++){
															if(j == 0 && k == 0){
																make2[j][k] = 1;
															}else if(k == 0){
																make2[j][k] = make2[j-1][k] ^ 1; 
															}else{
																make2[j][k] = make2[j][k-1] ^ 1;
															}
														}
													}
													boolean[] bool = new boolean[4];
													bool[i] = true;
													bool[l] = true;
													int temp = 0;
													for(int y = 0;y < 4;y++){
														
														if(bool[y]){
															temp += count(arr[y],make);
														}else{
															temp += count(arr[y],make2);
														}
														
													}
													ans = Math.min(ans,temp);
													temp = 0;
													for(int y = 0;y < 4;y++){
														
														if(bool[y]){
															temp += count(arr[y],make2);
														}else{
															temp += count(arr[y],make);
														}
														
													}
													ans = Math.min(ans,temp);
												}
												
											}
											w.println(ans);
											w.close();
										}
										int count(int[][] arr2,int[][] arr3){
											int count = 0;
											for(int i = 0;i < arr2.length;i++){
												for(int j = 0;j < arr2.length;j++){
													if(arr2[i][j] != arr3[i][j]){
														count++;
													}
												}
											}
											return count;
										}
										static class Pair implements Comparable<Pair>{
											double a;
											double b;
											
											Pair(double a,double b){
												this.a = a;
												this.b = b;
												
											}
											public boolean equals(Object o)
											{
												Pair p = (Pair)o;
												return (p.a==this.a && p.b== this.b);
											}
											public int compareTo(Pair p){
												return Double.compare(this.a,p.a);
											}
											public int hashCode()
											{
												return new Double(a).hashCode()*31 + new Double(b).hashCode()*17;
											}
										}
									} 