完美对

class Solution {
private:
	int n, k;
	int allSameNum = 0;
	//<code：形如+1-2+3，code对应的物品个数>
	unordered_map<string, int> memo;
	string getAntiCode(const string &s) {
		string r;
		for (char c : s) {
			if (c == '+')
				r += '-';
			else if (c == '-')
				r += '+';
			else
				r += c;
		}
		return r;
	}
public:
	Solution() {
		cin >> n >> k;
		int temp, last;
		for (int i = 0; i < n; i++)
		{
			string code;
			bool allSame = true;
			for (int j = 0; j < k; j++)
			{
				cin >> temp;
				if (j == 0)
					last = temp;
				else {
					if (temp != last)
						allSame = false;
					if (temp - last > 0)
						code += '+';
					code += to_string(temp - last);
					last = temp;
				}
			}
			if (allSame)
				allSameNum += 1;
			else if (memo.count(code))
				++memo[code];
			else
				memo[code] = 1;
		}
	}
	void solve() {
		int r = 0;
		for (const auto &m : memo) {
			string antiCode = getAntiCode(m.first);
			if (memo.count(antiCode))
				r += m.second * memo[antiCode];
		}
		r /= 2;
		r += allSameNum * (allSameNum - 1) / 2;
		cout << r << endl;
	}
};


int main()
{
	ios::sync_with_stdio(false);
	Solution s;
	s.solve();
	return 0;
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] params = br.readLine().trim().split(" ");
        int n = Integer.parseInt(params[0]), k = Integer.parseInt(params[1]);
        int[][] fields = new int[n][k];
        HashMap<Integer, ArrayList<Integer>> counter = new HashMap<>();
        int count = 0;
        for(int i = 0; i < n; i++){
            String[] row = br.readLine().trim().split(" ");
            for(int j = 0; j < k; j++)
                fields[i][j] = Integer.parseInt(row[j]);
            // 计算出差分之和
            int diffSum = fields[i][k - 1] - fields[i][0];
            // 检查相反数是否在里面，并检查是否是完美对
            if(counter.containsKey(-diffSum)){
                for(int j = 0; j < counter.get(-diffSum).size(); j++)
                    if(isValid(i, counter.get(-diffSum).get(j), fields)) count ++;
            }
            if(counter.containsKey(diffSum))
                counter.get(diffSum).add(i);
            else{
                ArrayList<Integer> path = new ArrayList<>();
                path.add(i);
                counter.put(diffSum, path);
            }
        }
        System.out.println(count);
    }
    
    private static boolean isValid(int i, int j, int[][] fields) {
        int val = fields[i][0] + fields[j][0];
        for(int fi = 1; fi < fields[0].length; fi++)
            if(fields[i][fi] + fields[j][fi] != val) return false;
        return true;
    }
}

def count(n, k, a_list):
    cnt = 0
    delta_map = dict()
    for i in range(n):
        delta_list = []
        for m in range(k-1):
            delta_list.append(a_list[i][m+1] - a_list[i][0])
        p_str = ' '.join([str(j) for j in delta_list])
        n_str = ' '.join([str(-j) for j in delta_list])
        if delta_map.get(n_str):
            cnt += delta_map.get(n_str)
        if delta_map.get(p_str):
            delta_map[p_str] += 1
        else:
            delta_map[p_str] = 1
    return cnt

def judge(a, b):
    n = a[0] + b[0]

    for i in range(1, len(a)):
        if a[i] + b[i] != n:
            return False

    return True

n, k = map(int, input().split())
a = [[] for i in range(n)]

for i in range(n):
    a[i] = input().split()

for i in range(n):
    for j in range(len(a[i])):
        a[i][j] = int(a[i][j])

cnt = 0

for i in range(n-1):
    for j in range(i+1, n):
        if judge(a[i], a[j]) == True:
            cnt += 1

print(cnt)

import java.util.*;
  
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
         
        int n = scan.nextInt(),k = scan.nextInt(),res = 0;
        int[][] num = new int[n][k];
        HashMap<String,Integer> table = new HashMap<>();
        for(int i = 0; i<n; i++){
            if(!scan.hasNextInt()){
                break;
            }
            int min = scan.nextInt();
            for(int j = 1; j<k; j++){
                if(scan.hasNextInt()){
                    num[i][j] = scan.nextInt() - min;
                }
            }
        }
        for(int i = 0; i<n; i++){
            String[] key = inttostr(num[i]);
            if(table.containsKey(key[1])){
                res += table.get(key[1]);
            }
            if(table.containsKey(key[0])){
                table.replace(key[0],table.get(key[0])+1);
            }else{
                table.put(key[0],1);
            }
        }
        System.out.println(res);
         
    }
     
    public static String[] inttostr(int[] a){
        String[] buffer = new String[2];
        buffer[0] = Arrays.toString(a);
        for(int i = 0; i<a.length; i++){
            a[i] = -a[i];
        }
        buffer[1] = Arrays.toString(a);
        return buffer;
    }
          
}

import javax.swing.plaf.IconUIResource;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

public class Solution2_1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // n 个物品
        int n = sc.nextInt();
        // k 个属性
        int k = sc.nextInt();
        int[][] items = new int[n][k];
        // 输入 items
        for(int i = 0; i < n; i++){
            for(int j = 0; j < k; j++){
                items[i][j] = sc.nextInt();
            }
        }
        int res = 0;
        // 形成查分数组，并且将其形成字符串，放入map
        // key: 字符串   value: 字符串出现次数
        HashMap<String, Integer> map = new HashMap<>();
        for(int i = 0; i < n; i++){
            StringBuilder s = new StringBuilder();
            StringBuilder s_opp = new StringBuilder();
            for(int j = 1; j < k; j++) {
                int diff = items[i][j] - items[i][j - 1];
                s.append(String.valueOf(diff)).append(",");
                s_opp.append(String.valueOf(-diff)).append(",");
            }
            // 查看有没有相反的完美对
            if(map.containsKey(s_opp.toString()))
                res += map.get(s_opp.toString());   // 计数
            map.put(s.toString(),map.getOrDefault(s.toString(),0)+1);
        }
        System.out.println(res);

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        int ans = 0;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = null;
        try {
            s = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        String[] s1 = s.split(" ");
        int n = Integer.parseInt(s1[0]);
        int k = Integer.parseInt(s1[1]);
        int[][] el = new int[n][k];
        for (int i = 0; i < n; i++) {
            String[] s2 = new String[k];
            try {
                s2 = br.readLine().trim().split(" ");
            } catch (IOException e) {
                e.printStackTrace();
            }
            for (int j = 0; j < k; j++) {
                el[i][j] = Integer.parseInt(s2[j]);
            }
        }
        Arrays.sort(el, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return (o1[0] - o1[1]) - (o2[0] - o2[1]);
            }
        });
        int mid = 0;
        for (int i = 0; i < n; i++) {
            if (el[i][0]-el[i][1]>0){
                mid = i;
                break;
            }
        }
        for (int i = 0; i < mid; i++) {
            for (int j = n-1; j >=mid ; j--) {
                if ((el[i][0] - el[i][1]) + (el[j][0] - el[j][1]) == 0) {
                    for (int l = 1; l < k; l++) {
                        int num = el[i][0] + el[j][0];
                        if (el[i][l] + el[j][l] != num) {
                            break;
                        }
                        if (l == k - 1) {
                            ans++;
                        }
                    }
                }else if((el[i][0] - el[i][1]) + (el[j][0] + el[j][1]) < 0){
                    break;
                }
            }
        }
        System.out.println(ans);
    }
}