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.*;
import java.io.*;

public class P961C
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        Board[] boards = new Board[4];
        for(int i = 0; i < 4; ++i)
        {
            String[] g = new String[n];
            for(int j = 0; j < n; ++j)
            {
                g[j] = in.next();
            }
            boards[i] = new Board(g);
        }

        int minimum = Integer.MAX_VALUE;
        Permutation p = new Permutation(4);
        while(p.hasNext())
        {
            int[] order = p.next();
            int t = boards[order[0]].topLeftOne + boards[order[1]].topLeftZero + boards[order[2]].topLeftZero + boards[order[3]].topLeftOne;
            minimum = Math.min(minimum, t);
            t = boards[order[0]].topLeftZero + boards[order[1]].topLeftOne + boards[order[2]].topLeftOne + boards[order[3]].topLeftZero;
            minimum = Math.min(minimum, t);
        }

        out.println(minimum);

        out.close();
    }

    private static class Board
    {
        private String[] grids;
        int topLeftZero;
        int topLeftOne;

        public Board(String[] g)
        {
            grids = g;
            topLeftZero = topLeft('0');
            topLeftOne = topLeft('1');
        }

        private int topLeft(char c)
        {
            int cost = 0;
            for(int i = 0; i < grids.length; ++i)
            {
                for(int j = 0; j < grids[i].length(); ++j)
                {
                    if((i + j) % 2 == 0)
                    {
                        if(grids[i].charAt(j) != c)
                        {
                            ++cost;
                        }
                    }
                    else
                    {
                        if(grids[i].charAt(j) == c)
                        {
                            ++cost;
                        }
                    }
                }
            }
            return cost;
        }
    }

    private static class Permutation
    {
        private int[] numbers;
        private boolean first;

        public Permutation(int n)
        {
            numbers = new int[n];
            for(int i = 0; i < n; ++i)
            {
                numbers[i] = i;
            }
            first = true;
        }

        public boolean hasNext()
        {
            if(first)
            {
                return true;
            }
            for(int i = 0; i + 1 < numbers.length; ++i)
            {
                if(numbers[i] < numbers[i + 1])
                {
                    return true;
                }
            }
            return false;
        }

        public int[] next()
        {
            if(first)
            {
                first = false;
                return numbers;
            }
            for(int i = numbers.length - 1; i >= 0; --i)
            {
                if(numbers[i - 1] < numbers[i])
                {
                    int j = i + 1;
                    while(j < numbers.length && numbers[j] > numbers[i - 1])
                    {
                        ++j;
                    }
                    int t = numbers[j - 1];
                    numbers[j - 1] = numbers[i - 1];
                    numbers[i - 1] = t;
                    j = numbers.length - 1;
                    while(i < j)
                    {
                        t = numbers[j];
                        numbers[j] = numbers[i];
                        numbers[i] = t;
                        ++i;
                        --j;
                    }
                    break;
                }
            }

            return numbers;
        }
    }
}
