int surfaceArea(vector<vector<int>> A) {
   int H = A.size();
    int W = A[0].size();
    int area = 0;
    
    for (int i = 0; i < H; i++) {
        for (int j = 0; j < W; j++) {
            if (A[i][j] > 0) {
                area += 2;
                
                area += max(A[i][j] - (i > 0 ? A[i-1][j] : 0), 0);
                area += max(A[i][j] - (i < H-1 ? A[i+1][j] : 0), 0);
                area += max(A[i][j] - (j > 0 ? A[i][j-1] : 0), 0);
                area += max(A[i][j] - (j < W-1 ? A[i][j+1] : 0), 0);
            }
        }
    }
    
    return area;
}

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

    /*
     * Complete the 'surfaceArea' function below.
     *
     * The function is expected to return an INTEGER.
     * The function accepts 2D_INTEGER_ARRAY A as parameter.
     */


    public static Long[] tmp;
    
    public static Long xf = 0xffffffl;
    public static Long yf = 0xffffl;
    public static Long zf = 0xffl;
    
    public static void miniproc(Long k, Set<Long> s)  {
        if (s.contains(k)) {
            s.remove(k);
        } else {
            s.add(k);
        }
    }

    public static void proc(int x, int y, int z, Set<Long> xsides, Set<Long> ysides, Set<Long> zsides) {
        
        Long root = (x + 0) * xf +
                    (y + 0) * yf +
                    (z + 0) * zf;         
        
        Long right =(x + 1) * xf +
                    (y + 0) * yf +
                    (z + 0) * zf;    
                 
        Long back = (x + 0) * xf +
                    (y + 1) * yf +
                    (z + 0) * zf;
        
        Long top =  (x + 0) * xf +
                    (y + 0) * yf +
                    (z + 1) * zf; 
        miniproc(root,  xsides);
        miniproc(root,  ysides);
        miniproc(root,  zsides);
        miniproc(right, xsides);
        miniproc(back,  ysides);
        miniproc(top,   zsides);
    }

    public static int calcsize(Set<Long> a, Set<Long> b, Set<Long> c) {
        return a.size() + b.size() + c.size();
    }

    public static int surfaceArea(List<List<Integer>> A) {
    // Write your code here
        tmp = new Long[6];
        Set<Long> xsides = new HashSet<>();
        Set<Long> ysides = new HashSet<>();
        Set<Long> zsides = new HashSet<>();
        for (int y = 0; y < A.size(); y++) {
            List<Integer> parts = A.get(y);
            for (int x = 0; x < parts.size(); x++) {
                int h = parts.get(x);
                for (int z = 0; z < h; z++) {
                    proc(x, y, z, xsides, ysides, zsides);
                }
            }
        }
        return xsides.size() + ysides.size() + zsides.size();
    }

}

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        String[] firstMultipleInput = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");

        int H = Integer.parseInt(firstMultipleInput[0]);

        int W = Integer.parseInt(firstMultipleInput[1]);

        List<List<Integer>> A = new ArrayList<>();

        IntStream.range(0, H).forEach(i -> {
            try {
                A.add(
                    Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
                        .map(Integer::parseInt)
                        .collect(toList())
                );
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        });

        int result = Result.surfaceArea(A);

        bufferedWriter.write(String.valueOf(result));
        bufferedWriter.newLine();

        bufferedReader.close();
        bufferedWriter.close();
    }
}