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.lang.*;
import static java.lang.Math.min;
import static java.lang.Math.max;

public class Main {

    static class Task {

        int n, ans = Integer.MAX_VALUE;
        String s1 = "", s2 = "";
        String[] a1;

        void permutation(int pos, int[] a) {
            if (pos == a.length - 1) {
                String[] s = new String[2 * n];
                for (int i = 0; i < 2 * n; i++) {
                    s[i] = "";
                }
                for (int i = 0; i < n; i++) {
                    s[i] += a1[n * a[0] + i];
                    s[i] += a1[n * a[3] + i];
                }
                int f = 0;
                for (int i = n; i < 2 * n; i++) {
                    s[i] += a1[n * a[1] + f];
                    s[i] += a1[n * a[2] + f];
                    f++;
                }
                int cnt1 = 0, cnt2 = 0;
                for (int i = 0; i < 2 * n; i++) {
                    for (int j = 0; j < 2 * n; j++) {
                        if (i % 2 == 0) {
                            if (s1.charAt(j) != s[i].charAt(j)) {
                                cnt1++;
                            }
                            if (s2.charAt(j) != s[i].charAt(j)) {
                                cnt2++;
                            }
                        } else {
                            if (s2.charAt(j) != s[i].charAt(j)) {
                                cnt1++;
                            }
                            if (s1.charAt(j) != s[i].charAt(j)) {
                                cnt2++;
                            }
                        }
                    }
                }
                ans = min(ans, min(cnt1, cnt2));
            } else {
                for (int i = pos; i < a.length; i++) {
                    int temp = a[i];
                    a[i] = a[pos];
                    a[pos] = temp;
                    permutation(pos + 1, a);
                    temp = a[i];
                    a[i] = a[pos];
                    a[pos] = temp;
                }
            }
        }

        void solve(int test, FastScanner in, PrintWriter out) throws IOException {
            n = in.nextInt();
            a1 = new String[4 * n];
            for (int i = 0; i < 4 * n; i++) {
                a1[i] = in.nextToken();
            }

            for (int i = 0; i < 2 * n; i++) {
                if (i % 2 == 0) {
                    s1 += '0';
                    s2 += '1';
                } else {
                    s2 += '0';
                    s1 += '1';
                }
            }

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

            permutation(0, a);

            out.println(ans);
        }
    }

    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
//        FastScanner in = new FastScanner("lemonade.in");
//        PrintWriter out = new PrintWriter(new FileWriter("lemonade.out"));
        new Task().solve(1, in, out);
        out.close();
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer token;

        public FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public String nextToken() {
            while (token == null || !token.hasMoreTokens()) {
                try {
                    token = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return token.nextToken();
        }

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

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

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