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.
/*
I made a dsu of size n, then for each pair of adjacent elements in the first permutation, i checked whether these elements are 
adjacent in all other permutations, if yes, i united them. So, if two numbers are in the same disjoint set, then they form a valid 
subarray, so i counted the number of pairs in each disjoint set and printed the sum of them.


*/
import java.util.*;
import java.io.*;
public class lp1{ 
static PrintWriter out = new PrintWriter(System.out);
static int[] p,sz;
static int find(int x)
{
     if(x==p[x])
        return x;
     return p[x] = find(p[x]);
}
static void union(int x,int y){
   int xr = find(x),yr= find(y);
   if(xr==yr)
      return ;
    p[xr] =yr;
    sz[yr] = sz[yr]+sz[xr];
}
static boolean check(int x,int y,int m,int a[][])
{
     for(int i=1;i<m;i++)
        {
           if((a[i][x]-a[i][y])!=1)
                return false;
        }
     return true;
}
public static void main(String[] args){

int n = ni();
int m = ni();

int a[][] = new int[m][n];

for(int i=0;i<m;i++)  // in first permutation i will store actual numbers in other i will store the index of that number
  for(int j=0;j<n;j++) // numbers are starting from index 1
    {
       if(i==0)
         a[i][j] = ni()-1;
       else{
         int x = ni()-1;
         a[i][x]=j;
       }
    }
p = new int[n];
sz = new int[n];
for(int i=0;i<n;i++)
  { p[i] =i; sz[i]=1;}
for(int i=1;i<n;i++)
{
    if(check(a[0][i],a[0][i-1],m,a))
       union(a[0][i-1],a[0][i]);
}
boolean vis[] =new boolean[n];
long ans=n;
for(int i=0;i<n;i++)
{
    int ir = find(i);
    if(vis[ir]==false)
     {
       long s = sz[ir];
       vis[ir]=true;
       ans = ans + (s*(s-1))/2;
     }
}
   pn(ans);
   out.flush();
} 
static int[] ai(int n)  // it will give in array of size n
{
    int a[] = new int[n];
    for(int i=0;i<n;i++)
        a[i] = ni();
    return a;
}
static long[] al(int n)  // it will give in array of size n
{
    long a[] = new long[n];
    for(int i=0;i<n;i++)
        a[i] = nl();
    return a;
}

static void p(Object o)
{
   out.print(o);
}
static void pn(Object o)
{
    out.println(o);
}
static int abs(int x)
{
    return x>0 ? x : -x;
}
static long gcd(long a,long b)
{
       if(b%a==0)
          return a;
          return gcd(b%a,a);
}
static void subtract_1(char s[]) // it will subtract 1 from the given number.  number should be positive
{
      if(s[0]=='0') // number is zero
          return;
     int n = s.length,i=n-1;
     while(s[i]=='0')
       i--;
     s[i] = (char)((int)(s[i]-'0') + 47);
   
     for(int j=i+1;j<n;j++)
         s[j]='9';
}
static long pow(long a,long b,long md)
{ 
    long ans=1;
    while(b>0)
    {
         if(b%2==1)
           ans = (ans*a)%md;
           a = (a*a)%md;
           b = b/2;
    }
   return ans;
}
static long min(long a,long b){
 
     return a<b ? a : b;
}
static long max(long a,long b){
     return a>b ? a : b;
}
static boolean pal(String s)
{
   int n = s.length(),i1=0,i2=n-1;
 
     while(i1<i2)
     {
        if(s.charAt(i1)!=s.charAt(i2))
             return false;
             i1++; i2--;
     }
       return true;
}
static String rev(String r)
{
    String s = "";
    int i= r.length()-1;
 
    while(i>=0)
    {
        s=s+r.charAt(i);
        i--;   
    }
       return s;
}
static FastReader sc=new FastReader(); 
 
      static int ni(){
                 int x = sc.nextInt();
                 return(x);
        }
      static long nl(){
              long x = sc.nextLong();
              return(x);
         }
      static String n(){
                 String str = sc.next();
                     return(str);
       }
     static String ns(){
                 String str = sc.nextLine();
                   return(str);
      }
     static double nd(){
               double d = sc.nextDouble();
                 return(d);
       }
  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 nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
}