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.util.Scanner;

public class C961 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        char[][][] B = new char[4][N][];
        for (int part=0; part<4; part++) {
            for (int r=0; r<N; r++) {
                B[part][r] = in.next().toCharArray();
            }
        }
        int[] perm = initialPermutation(4);
        int min = 4*N*N;
        do {
            min = Math.min(min, solve(B, perm, '0'));
            min = Math.min(min, solve(B, perm, '1'));
        } while (nextPermutation(perm) != null);
        System.out.println(min);
    }

    static int solve(char[][][] B, int[] perm, char even) {
        char odd = (even == '0') ? '1' : '0';
        int count = 0;
        int N = B[0].length;
        for (int r=0; r<2*N; r++) {
            for (int c=0; c<2*N; c++) {
                char expected = ((r+c)%2 == 0) ? even : odd;
                int idx;
                if (r < N) {
                    if (c < N) {
                        idx = perm[0];
                    } else {
                        idx = perm[1];
                    }
                } else {
                    if (c < N) {
                        idx = perm[2];
                    } else {
                        idx = perm[3];
                    }
                }
                char actual = B[idx][r%N][c%N];
                if (actual != expected) {
                    count++;
                }
            }
        }
        return count;
    }

    static int[] initialPermutation(int N) {
        int[] perm = new int[N];
        for (int n=0; n<N; n++) {
            perm[n] = n;
        }
        return perm;
    }

    static int[] nextPermutation(int[] perm) {
        int i = perm.length-1;
        while (i > 0 && perm[i-1] > perm[i]) i--;
        if (i == 0) return null;
        int j = i;
        i--;
        while (j < perm.length && perm[j] > perm[i]) j++;
        j--;
        int temp = perm[i];
        perm[i] = perm[j];
        perm[j] = temp;
        i++;
        j = perm.length-1;
        while (i < j) {
            temp = perm[i];
            perm[i] = perm[j];
            perm[j] = temp;
            i++;
            j--;
        }
        return perm;
    }

}
