Acingel is a small town. There was only one doctor here — Miss Ada. She was very friendly and nobody has ever said something bad about her, so who could've expected that Ada will be found dead in her house? Mr Gawry, world-famous detective, is appointed to find the criminal. He asked m neighbours of Ada about clients who have visited her in that unlucky day. Let's number the clients from 1 to n. Each neighbour's testimony is a permutation of these numbers, which describes the order in which clients have been seen by the asked neighbour.

However, some facts are very suspicious – how it is that, according to some of given permutations, some client has been seen in the morning, while in others he has been seen in the evening? "In the morning some of neighbours must have been sleeping!" — thinks Gawry — "and in the evening there's been too dark to see somebody's face...". Now he wants to delete some prefix and some suffix (both prefix and suffix can be empty) in each permutation, so that they'll be non-empty and equal to each other after that — some of the potential criminals may disappear, but the testimony won't stand in contradiction to each other.

In how many ways he can do it? Two ways are called different if the remaining common part is different.

Input

The first line contains two integers n and m (1 ≤ n ≤ 100 000, 1 ≤ m ≤ 10) — the number of suspects and the number of asked neighbors.

Each of the next m lines contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n). It is guaranteed that these integers form a correct permutation (that is, each number from 1 to n appears exactly once).

Output

Output a single integer denoting the number of ways to delete some prefix and some suffix of each permutation (possibly empty), such that the remaining parts will be equal and non-empty.

Examples

Input

3 2
1 2 3
2 3 1


Output

4


Input

5 6
1 2 3 4 5
2 3 1 4 5
3 4 5 1 2
3 5 4 2 1
2 3 5 4 1
1 2 3 4 5


Output

5


Input

2 2
1 2
2 1


Output

2

Note

In the first example, all possible common parts are [1], [2], [3] and [2, 3].

In the second and third examples, you can only leave common parts of length 1.
import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    protected final InputReader in;
    protected final PrintWriter out;

    public Main(final InputReader in, final PrintWriter out) {
        this.in = in;
        this.out = out;
    }

    private static PrintWriter getOutput(final String filename) throws IOException {
        if (filename == null || filename.isEmpty()) {
            return new PrintWriter(new OutputStreamWriter(System.out));
        } else {
            return new PrintWriter(new FileWriter(filename + ".out"));
        }
    }

    public static void main(final String[] args) throws NumberFormatException, IOException {
        final String filename = "";
        final long time = System.currentTimeMillis();
        try (final InputReader in = new InputReader(filename); final PrintWriter out = getOutput(filename)) {
            new Main(in, out).solve();
        }
//        System.err.println("Running time: " + (System.currentTimeMillis() - time) + "ms");
    }

    private int[] readIntArray(final int n) throws IOException {
        final int[] result = new int[n];
        for (int i = 0; i < n; i++)
            result[i] = in.nextInt() - 1;

        return result;
    }

    public void solve() throws NumberFormatException, IOException {
        final int n = in.nextInt();
        final int m = in.nextInt();

        final int[] r0 = readIntArray(n);

        final int[] longestPossible = new int[n];
        for (int i = 0; i < n; i++) longestPossible[i] = n - i;

        final int[] where = new int[n];
        for (int rowNumber = 1; rowNumber < m; rowNumber++) {
            final int[] currentRow = readIntArray(n);
            for (int i = 0; i < n; i++) where[currentRow[i]] = i;

            for (int start = 0; start < n; ) {
                final int startInCurrentRow = where[r0[start]];
                int length = 1;
                while (length < longestPossible[start] &&
                        start + length < n &&
                        startInCurrentRow + length < n &&
                        r0[start + length] == currentRow[startInCurrentRow + length]) length++;

                for (int i = start, j = length; j > 0; i++, j--) longestPossible[i] = j;

                start += length;
            }
        }

        long result = 0;
        for (int i = 0; i < n; i++) result += longestPossible[i];

        out.println(result);
    }

    private void assertTrue(final boolean t) {
        if (!t) throw new RuntimeException();
    }
}

class InputReader implements Closeable {
    private StringTokenizer st;
    private final BufferedReader in;

    public InputReader(final String filename) throws IOException {
        if (filename == null || filename.isEmpty())
            in = new BufferedReader(new InputStreamReader(System.in));
        else
            in = new BufferedReader(new FileReader(filename + ".in"));
    }

    public boolean hasNextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = in.readLine();
            if (line == null)
                return false;
            st = new StringTokenizer(line);
        }
        return true;
    }

    public String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = in.readLine();
            if (line == null)
                return null;
            st = new StringTokenizer(line);
        }
        return st.nextToken();
    }

    public String readLine() throws IOException {
        return in.readLine();
    }

    public int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    @Override
    public void close() throws IOException {
        in.close();
    }
}