//Generated at 2019-07-07 20:14:47 UTC+8
//Created by Alphagocc
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
//C11
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
// C++11
#include <array>
#include <atomic>
#include <chrono>
#include <codecvt>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
// namespace IO 
namespace IO
{
template <typename T>
void __RI(T &x)
{
    int ch = getchar(), neg = 1;
    x = 0;
    for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = getchar())
        ;
    if (ch == EOF) return;
    if (ch == '-') neg = -1;
    for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    x *= neg;
}
void R(int &x) { __RI(x); }
void R(int64_t &x) { __RI(x); }
template <typename T1, typename T2>
void R(std::pair<T1, T2> &x)
{
    R(x.first);
    R(x.second);
}
template <typename T>
void R(std::vector<T> &x)
{
    for (auto &i : x) { R(i); }
}
template <typename T>
void R(T &x)
{
    std::cin >> x;
}
template <typename T, typename... Args>
void R(T &x, Args &... args)
{
    R(x), R(args...);
}
char space = ' ';
template <typename T>
void __WI(T x)
{
    if (x == 0) putchar('0');
    if (x < 0) putchar('-'), x = -x;
    char ch[ 64 ];
    int  pos = 0;
    while (x) ch[ pos++ ] = x % 10 + 48, x /= 10;
    while (pos) putchar(ch[ --pos ]);
}
void W() {}
void W(const int &x) { __WI(x); }
void W(const int64_t &x) { __WI(x); }
void W(const double &x) { printf("%lf",static_cast<double>(x)); }
void W(const char &x) { putchar(x); }
void W(const std::string &x) { printf("%s", x.c_str()); }
template <typename T1, typename T2>
void W(const std::pair<T1, T2> &x)
{
    W(x.first);
    W(space);
    W(x.second);
}
template <typename T>
void W(const std::vector<T> &x)
{
    for (auto it = x.cbegin();it != x.cend(); it++)
    {
        W(*it);
        W(space);
    }
    W('\n');
}
template <typename T>
void W(const T &x)
{
    std::cout << x;
}
template <typename T, typename... Args>
void W(const T &x,const Args &... args)
{
    W(x), W(space), W(args...);
}
template <typename... Args>
void WL(const Args &... args)
{
    W(args...), W('\n');
}
}; // namespace IO

using namespace std;

#define REP(i, x, y) for (int i = x;i < y; i++)

const int8_t  INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF  = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
int a[100][100];
bool check(int64_t x)
{
    int64_t p=0;
    while(p*p<x) p++;
    return (p*p==x);
}
int main()
{
    int n,d;
    cin >> n >> d;
    for (int i=0;i<n;i++)
    {
        for (int j=0;j<d;j++)
        {
            cin >> a[i][j];
        }
    }
    int ans=0;
    for (int i=0;i<n;i++)
    {
        for (int j=i+1;j<n;j++)
        {
            int64_t sum=0;
            for (int k=0;k<d;k++)
            {
                sum+=(a[i][k]-a[j][k])*(a[i][k]-a[j][k]);
            }
            ans+=check(sum);
        }
    }
    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 256