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
//    A Computer is Like a mischievous genie.
//    It will give you exactly what you ask for,
//    but not always what you want
//    A code by Rahul Verma


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.TreeMap;


public class Main {


    static class Clock {

        protected long start, stop;

        public void start() {
            start = System.currentTimeMillis();
        }

        public void stop() {
            stop = System.currentTimeMillis();
        }

        public String getTime() {
            return ((stop - start) + " ms");
        }
    }


    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String[] nextSArray() {
            String sr[] = null;
            try {
                sr = br.readLine().trim().split(" ");
            } catch (IOException e) {
                e.printStackTrace();
            }
            return sr;
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return str;
        }
    }


    static long powmodulo(long a, long p) {
        if (p == 0) {
            return 1 % mod;
        }
        if (p == 1) {
            return a % mod;
        }
        long ans = 1;
        while (p > 0) {
            if ((p & 1) > 0) {
                ans = (ans * a) % mod;
            }
            a = (a * a) % mod;
            p = p >> 1;
        }
        return ans % mod;
    }


    static long mod = 1000000007;

    static long gcd(long a, long b) {
        if (a == 0) {
            return b;
        }
        return gcd(b % a, a);
    }

    static long fast_powerNumbers(long a, long n) {
        if (n == 1) {
            return a;
        }
        long ans = fast_powerNumbers(a, n / 2);
        if (n % 2 == 0) {
            return (ans * ans);
        } else {
            return ((ans * ans) * (a));
        }
    }


    static void dfs_helper(int[][] arr, int i, int j, int team, int n, int m) {
        arr[i][j] = team;
        if (i - 1 >= 0 && arr[i - 1][j] == 1) {
            dfs(arr, i - 1, j, team, n, m);
        }
        if (j - 1 >= 0 && arr[i][j - 1] == 1) {
            dfs(arr, i, j - 1, team, n, m);
        }
        if (i + 1 < n && arr[i + 1][j] == 1) {
            dfs(arr, i + 1, j, team, n, m);
        }
        if (j + 1 < m && arr[i][j + 1] == 1) {
            dfs(arr, i, j + 1, team, n, m);
        }

    }

    static void dfs(int[][] arr, int i, int j, int team, int n, int m) {
        dfs_helper(arr, i, j, team, n, m);

    }

    static int parent[];
    static int rank[];

    static int find(int i) {
        if (parent[i] == -1) {
            parent[i] = i;
            return i;
        }

        if (parent[i] == i) {
            return i;
        } else {
            parent[i] = find(parent[i]);
        }
        return parent[i];

    }

    static void unite(int s1, int s2) {

        if (rank[s1] > rank[s2]) {
            parent[s2] = s1;
            rank[s1] += rank[s2];
        } else {
            parent[s1] = s2;
            rank[s2] += rank[s1];
        }
    }


    public static long arr[];

//    static void seive(int n) {
//        arr = new int[n + 1];
//        arr[0] = arr[1] = 1;
//        for (int i = 4; i <= n; i = i + 2) {
//            arr[i] = 1;
//        }
//        for (int i = 3; i * i <= n; i = i + 2) {
//            if (arr[i] == 0) {
//                for (int j = i * i; j <= n; j = j + i) {
//                    arr[j] = 1;
//                }
//
//            }
//        }
//    }


    public static int fun(String s ,int turn) {
        if(s==null||s.length()==0)
            return turn;

        double d = Double.parseDouble(s);
        double x = Math.sqrt(d);

        if(Math.ceil(x)==Math.floor(x))
        {
            return turn;
        }
        int min = 200;
        if(s.length()>1&&s.charAt(1)!='0')
        {
            min=Math.min(min, fun(s.substring(1),turn+1));
        }
        for (int i = 1; i <s.length()-1 ; i++) {

            min=Math.min(min, fun(s.substring(0,i)+s.substring(i+1),turn+1));
        }
        min=Math.min(min, fun(s.substring(0,s.length()-1),turn+1));
        return min;
    }

    public static void main(String[] args) throws Exception {
        FastReader sc = new FastReader();

        Clock clock = new Clock();
        clock.start();
//        int t1 =sc.nextInt();
//
//        for (int t = 0; t <t1; t++) {
//        }
//        out.close();
        int n =sc.nextInt();
        int a[][]=new int[n][n];
        int b[][]=new int[n][n];
        int c[][]=new int[n][n];
        int d[][]=new int[n][n];
        ArrayList<Integer>al=new ArrayList<>();
        for (int i = 0; i <n ; i++) {
            String s =sc.nextLine();
            for (int j = 0; j < n; j++) {
                a[i][j]=s.charAt(j)-'0';
            }
        }
        sc.nextLine();
//        for (int i = 0; i <n ; i++) {
//            for (int j = 0; j < n; j++) {
//                System.out.print(a[i][j]+" ");
//            }
//            System.out.println();
//        }
        for (int i = 0; i <n ; i++) {
            String s =sc.nextLine();
            for (int j = 0; j < n; j++) {
                b[i][j]=s.charAt(j)-'0';
            }
        } sc.nextLine();
        for (int i = 0; i <n ; i++) {
            String s =sc.nextLine();
            for (int j = 0; j < n; j++) {
                c[i][j]=s.charAt(j)-'0';
            }
        } sc.nextLine();
        for (int i = 0; i <n ; i++) {
            String s =sc.nextLine();
            for (int j = 0; j < n; j++) {
                d[i][j]=s.charAt(j)-'0';
            }
        }
        int ac=0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if((i+j)%2!=a[i][j])
                    ++ac;
            }
        }
       al.add(ac);
        ac=0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if((i+j)%2!=b[i][j])
                    ++ac;
            }
        }
        al.add(ac);

        ac=0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if((i+j)%2!=c[i][j])
                    ++ac;
            }
        }
        al.add(ac);
        ac=0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if((i+j)%2!=d[i][j])
                    ++ac;
            }
        }
        al.add(ac);
        Collections.sort(al);

        int ans = al.get(0)+al.get(1) + (n*n - al.get(2)) + (n*n - al.get(3));
        System.out.println(ans);


}}

class trio{
    long rs;int egg;int choco;
    trio(long rs,int egg,int choco)
    {
        this.rs=rs;
        this.egg=egg;
        this.choco=choco;
    }
}

class Pair{

    int a,b;
    Pair(int a,int b)
    {
        this.a=a;
        this.b=b;
    }
}
class DSU
{
    int parent[];
    int rank[];
    long arr[] = Main.arr;
    long sum[] ;
    DSU(int n)
    {
        this.parent=new int[n];
        this.rank=new int[n];
        sum=new long[n];
        Arrays.fill(parent,-1);
        Arrays.fill(rank,1);
        for (int i = 0; i <n ; i++) {
            sum[i]=arr[i];
        }
    }

    int find(int s1)
    {
        if(parent[s1]==-1)
            return s1;
        return parent[s1]=find(parent[s1]);
    }

    void unite(int s1,int s2)
    {
        int p1=this.find(s1);
        int p2=this.find(s2);
        if(p1==p2)
            return;
        if(rank[p1]>rank[p2])
        {
            parent[p2]=p1;
            rank[p1]+=rank[p2];
           // System.out.println(arr[p2]);

            sum[p1]+=sum[p2];
            //sum[p2]+=sum[p1];

        }
        else
        {
            parent[p1]=p2;
            rank[p2]+=rank[p1];
            //System.out.println(arr[p1]);
            sum[p2]+=sum[p1];
            //sum[p1]+=sum[p2];
        }
    }


}

 class Gaph {

    HashMap<Integer, ArrayList<Integer>> hm;

    Gaph() {
        hm = new HashMap<>();
    }

    Gaph(int n) {

        hm = new HashMap<>();
        for (int i = 0; i < n; i++) {
            hm.put(i, new ArrayList<Integer>());
        }
    }

    // function for adding an edge.................................................
    public void addEdge(int a, int b, boolean isDir) {
        if (isDir) {
            if (hm.containsKey(a)) {
                hm.get(a).add(b);
            } else {
                hm.put(a, new ArrayList<>(Arrays.asList(b)));
            }
        } else {
            if (hm.containsKey(a)) {
                hm.get(a).add(b);
            } else if (!hm.containsKey(a)) {
                hm.put(a, new ArrayList<>(Arrays.asList(b)));
            }

            if (hm.containsKey(b)) {
                hm.get(b).add(a);
            } else if (!hm.containsKey(b)) {
                hm.put(b, new ArrayList<>(Arrays.asList(a)));
            }
        }
    }


}

// out.println(al.toString().replaceAll("[\\[|\\]|,]",""));

