/**
 * @author hauser
 */
import java.util.*;

public class dpsearch {
    int nrows;

    private static class Pair implements Comparable<Pair> {
        public int subset;
        public int val;
        Pair(int s, int v) {
            this.subset = s;
            this.val = v;
        }
        public int compareTo(Pair p2) {
            if (this.val > p2.val) {return 1; }
            else if (this.val < p2.val) {return -1; }
            else return 0;
        }
    }

    private static List<Integer> subsethelper(int curr, int limit, 
            List<Integer> odds, List<Integer> evens ) {
        if (curr==limit) { 
            odds.addAll(evens);
            return odds; }
        else {
            odds.addAll(evens);
            ListIterator<Integer> it = odds.listIterator();
            while (it.hasNext()){
                int val = it.next().intValue();
                it.set(new Integer(val*2));
            }
            it = evens.listIterator();
            while (it.hasNext()) {
                int val = it.next().intValue();
                it.set(new Integer(val*2+1));
            }
            return subsethelper(curr+1, limit, evens, odds);          
        }
 
    }

    private static List<Integer> validsubsets(int n) {
        List<Integer>odds = new ArrayList<Integer>();
        List<Integer>evens = new ArrayList<Integer>();
        odds.add(new Integer(1));
        evens.add(new Integer(0));
        return (subsethelper(1, n, odds, evens));
    }

    private static int subsetvalue(int subset, int row[]) {
        int sum = 0;
        for (int val : row) {
            if ((subset % 2)==1) {
                sum += val;
            }
            subset >>= 1;
        }
        return sum;
    }

    private static List<Pair> subsetvalues(List<Integer> subsets, int row[]) {
        // build a list of values of each of the subsets
        List<Pair> res = new ArrayList<Pair>();
        for (Integer I: subsets) {
            int i = I.intValue();
            res.add(new Pair(i, subsetvalue(i, row)));
        }
        return res;
    }

    private static boolean compat(int s1, int s2) {
        s2 = (s2<<1) | s2 | (s2>>1);
        return ((s1^s2) == (s1|s2));
    }

    private static Pair bestcompatval(Pair curr, List<Pair> prevList) {
        int currSubset = curr.subset;
        int currVal = curr.val;
        for (Pair prev : prevList) {
            int prevSubset = prev.subset;
            int prevVal = prev.val;
            if (compat(currSubset, prevSubset)) { 
                return new Pair(currSubset, prevVal+currVal); 
                }
        }
        return (curr);
    }

    public static int solve(int M[][]){
        int nrows = M.length;
        int ncols = M[0].length;
        List<Integer> vs = validsubsets(ncols);
        List<Pair> prev = subsetvalues(vs, M[0]);       
        for (int i=1; i<nrows; i++) {
            List<Pair> currRowVals = subsetvalues(vs, M[i]);
            List<Pair> newRowVals = new ArrayList<Pair>(currRowVals.size());
            for (Pair currRowVal : currRowVals) {
                newRowVals.add(bestcompatval(currRowVal, prev));
            }
            Collections.sort(newRowVals, Collections.reverseOrder()); 

            prev = newRowVals;
        }
        return prev.get(0).val;
    }

    public static void main(String argv[]) {
        int probSize = 15;
        int M[][] = new int[probSize][probSize];
        for (int i=0; i<probSize; i++) {
            for (int j=0; j<probSize; j++) {
                M[i][j] = 1;
            }
        }
        int maxChosen = solve(M);
        System.out.println(maxChosen);
    }
}