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.*;


public class check {
    static boolean DEBUG_FLAG = false;
    int INF = (int)1e9;
    long MOD = 1000000007;
    
    static void debug(String s) {
        if(DEBUG_FLAG) {
            System.out.print(s);
        }
    }
    
    int n;
    int[][][] c;
    int[][] s;
    boolean[] vis;
    
    int comp(int x, int b) {
        if(x==0||x==2) {
            if(b==0) return 1;
            else return 0;
        }
        return b;
    }
    
    int go(int m, int x, int b) {
//        System.out.println(x+" "+b);
        if(m>3) return 0;
        int cost = s[x][b];
        int min = INF;
        boolean f = false;
        vis[x] = true;
        for(int i=0; i<4; i++) {
            if(!vis[i]) {
                f = true;
                vis[i] = true;
                min = Math.min(min, go(m+1, i, comp(m, b)));
                vis[i] = false;
            }
        }
        if(!f) return cost;
        return cost + min;
    }
    
    
    void solve(InputReader in, PrintWriter out) throws IOException {
        n = in.nextInt();
        c = new int[4][n][n];
        for(int k=0; k<4; k++) {
            for(int i=0; i<n; i++) {
                String s = in.next();
                for(int j=0; j<n; j++) {
                    c[k][i][j] = s.charAt(j)-'0';
                }
            }
            if(k!=3) in.rl();
        }
        s = new int[4][2];
        for(int k=0; k<4; k++) {
            for(int i=0; i<n; i++) {
                for(int j=0; j<n; j++) {
                    if((i+j)%2==0) {
                        if(c[k][i][j]==1) {
                            s[k][0]++;
                        }
                    } else {
                        if(c[k][i][j]==0) {
                            s[k][0]++;
                        }
                    }
                }
            }
            for(int i=0; i<n; i++) {
                for(int j=0; j<n; j++) {
                    if((i+j)%2==0) {
                        if(c[k][i][j]==0) {
                            s[k][1]++;
                        }
                    } else {
                        if(c[k][i][j]==1) {
                            s[k][1]++;
                        }
                    }
                }
            }
        }
//        for(int i=0; i<4; i++) {
//            System.out.println(s[i][0]+" "+s[i][1]);
//        }
        int min = INF;
        for(int i=0; i<4; i++) {
            vis = new boolean[4];
            min = Math.min(min, go(0, i, 0));
            vis = new boolean[4];
            min = Math.min(min, go(0, i, 1));
        }
        out.println(min);
    }
    
    
    public static void main(String[] args) throws IOException {
        if(args.length>0 && args[0].equalsIgnoreCase("d")) {
            DEBUG_FLAG = true;
        }
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;//in.nextInt();
        long start = System.nanoTime();
        while(t-- >0) {
            new check().solve(in, out);
        }
        long end = System.nanoTime();
        debug("\nTime: " + (end-start)/1e6 + " \n\n");
        out.close();
    }
    
    static class InputReader {
        static BufferedReader br;
        static StringTokenizer st;
    
        public InputReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        
        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        void rl() {
            try {
                br.readLine();
            } catch(Exception e) {}
        }
        
        int nextInt() {
            return Integer.parseInt(next());
        }
        
        long nextLong() {
            return Long.parseLong(next());
        }
        
        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}