#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define fr first
#define sc second
#define all(a) (a).begin(), (a).end()
#define unique(a) a.resize(unique(a.begin(), a.end()) - a.begin())

using namespace std;

#ifdef ONPC
mt19937 rnd(223);
#else
mt19937 rnd(chrono::high_resolution_clock::now()
			.time_since_epoch().count());
#endif

#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

using ll = __int128;
#define int ll
using ld = double;

using me = long long;

const int basen = 36;
const int base = pow(10, me(basen));

// uncomment to multiply large numbers with fft
// basen should be even, at most 8
// with doubles in fft and basen = 8 works up to Big.v.size() = 1e6 (but fails for 1e6 + 5e4)
// #define BIGINT_USE_FFT

// division works in n^2 * log(base), where n = Big.v.size()

struct Big {
    vector<ll> v;
    bool minus = false;

    Big() {}
    Big(long long k) {
        if (k < 0) {
            minus = true;
            k = -k;
        }
        while (k) {
            v.push_back(k % base);
            k /= base;
        }
    }

    __int128 read128(string s) {
        __int128 res = 0;
        for(char c : s) res = res * 10 + (c-'0');
        return res;
    }

    Big(string s) {
        if (s[0] == '-') {
            s.erase(s.begin());
            minus = true;
        }
        reverse(s.begin(), s.end());
        while (s.size() % basen != 0)
            s.push_back('0');
        reverse(s.begin(), s.end());
        for (int i = 0; i < s.size(); i += basen)
            v.push_back(read128(s.substr(i, basen)));
        reverse(v.begin(), v.end());
        norm();
    }

    Big &operator += (const Big &other) {
        if (minus == other.minus) {
            _add_(v, other.v);
        } else {
//            if (_comp_(other.v, v)) {
                _sub_(v, other.v);
//            } else {
//                _sub2_(v, other.v);
//                minus ^= 1;
//            }
        }
        norm();
        return *this;
    }
    Big operator + (const Big &other) const {
        auto res = *this;
        return res += other;
    }

    Big operator - () const {
        Big res = *this;
        if (!v.empty()) res.minus ^= 1;
        return res;
    }
    Big &operator -= (const Big &other) {
        return *this += -other;
    }
    Big operator - (const Big &other) const {
        auto res = *this;
        return res -= other;
    }


    void norm() {
        while (!v.empty() && v.back() == 0)
            v.pop_back();
        if (v.empty())
            minus = false;
    }

    bool operator < (const Big &other) const {
        if (minus != other.minus) return minus;
        if (minus) return _comp_(other.v, v);
        else return _comp_(v, other.v);
    }
    bool operator > (const Big &other) const {
        return other < *this;
    }
    bool operator <= (const Big &other) const {
        return !(other < *this);
    }
    bool operator >= (const Big &other) const {
        return !(*this < other);
    }

    bool operator == (const Big &other) const {
        return minus == other.minus && v == other.v;
    }
    bool operator != (const Big &other) const {
        return !(*this == other);
    }

private:
    static void _sub_(vector<int> &a, const vector<int> &b) {
        a.resize(max(a.size(), b.size()) + 1, 0);
        for (int i = 0; i < b.size(); ++i)
            a[i] -= b[i];
        for (int i = 0; i + 1 < b.size() || a[i] < 0; ++i) {
            if (a[i] < 0) {
                a[i] += base;
                --a[i + 1];
            }
        }
        assert(a.back() >= 0);
        while (!a.empty() && a.back() == 0)
            a.pop_back();
    }

    static void _sub2_(vector<int> &a, const vector<int> &b) {
        a.resize(max(a.size(), b.size()) + 1, 0);
        for (int i = 0; i < a.size(); ++i)
            a[i] = (i < b.size() ? b[i] : 0) - a[i];
        for (int i = 0; i + 1 < a.size(); ++i) {
            if (a[i] < 0) {
                a[i] += base;
                --a[i + 1];
            }
        }
        assert(a.back() >= 0);
        while (!a.empty() && a.back() == 0)
            a.pop_back();
    }

    static void _add_(vector<int> &a, const vector<int> &b) {
        a.resize(max(a.size(), b.size()) + 1, 0);
        for (int i = 0; i < b.size(); ++i)
            a[i] += b[i];
        for (int i = 0; i + 1 < b.size() || a[i] >= base; ++i) {
            if (a[i] >= base) {
                a[i] -= base;
                ++a[i + 1];
            }
        }
        while (!a.empty() && a.back() == 0)
            a.pop_back();
    }

    static bool _comp_(const vector<int> &a, const vector<int> &b) {
        if (a.size() != b.size())
            return a.size() < b.size();
        for (int i = (int)a.size() - 1; i >= 0; --i)
            if (a[i] != b[i])
                return a[i] < b[i];
        return false;
    }

};

istream &operator >> (istream &i, Big &b) {
    string s;
    i >> s;
    b = Big(s);
    return i;
}



const int maxn = 1e5 + 100, inf = 1e9 + 100;


Big getmod(string s, int k, const Big&M) {
    vector<Big> v;
    Big sum = 0;
    for(int i=0;i<s.size();i+=k){
        string sub = s.substr(i,k);
        reverse(all(sub));
        Big num = Big(sub);
        sum += num;
        if(sum >= M) {
            sum -= M;
        }
    }
    return sum;
}

ll sum3(const vector<Big>& uni, const vector<int>&num, const Big& M) {
    ll ans = 0;
    for(int i=0;i<uni.size();i++){
        Big tar = M - uni[i];
        for(int j=i,k=uni.size()-1;j<=k;j++){
            if(uni[j] > tar) break;
            Big tar2 = tar-uni[j];
            while(k>j&&uni[k]>tar2)k--;
            if(uni[k]==tar2) {
//                cerr << i << " " << j << " " << k << endl;
                if(i==j&&j==k){
                    ans += ll(num[i])*(num[i]+1)*(num[i]+2)/6;
                }
                else if(i==j){
                    ans += ll(num[i])*(num[i]+1)/2*num[k];
                }
                else if(j==k){
                    ans += ll(num[i])*num[j]*(num[j]+1)/2;
                }
                else {
                    ans += ll(num[i])*num[j]*num[k];
                }
            }
        }
    }
    return ans;
}

#define cin cin
Big a[501];

void solve() {
    me n,k;
    n = 500;
    k = 20000;
    cin >> n >> k;
    string ms(k,'9');
    const Big M = Big(ms);
    for(int i=0;i<n;i++){
        string s;
        s = string(20000,'0');
        for(int i=0;i<s.size();i++)s[i] = '0' + rnd()%10;
        cin >> s;
//        cerr << s << endl;
        reverse(all(s));
        a[i] = getmod(s,k,M);
//        cerr << a[i] << endl;
    }
    sort(a,a+n);
    vector<Big> uni;
    vector<int> num;
    for(int i=0;i<n;i++){
        if(uni.size() && uni.back() == a[i]){
            num.back() ++;
        }
        else {
            uni.push_back(move(a[i]));
            num.push_back(1);
        }
    }
    ll ans = 0;
    if(uni[0] == Big(0)) {
        ans += ll(num[0]) * (num[0]+1) * (num[0]+2) / 6;
    }
    cerr << TIME << endl;
//    cerr << ans << endl;
    ans += sum3(uni,num,M);
//    cerr << ans << endl;
    ans += sum3(uni,num,M+M);
    cout << me(ans) << "\n";
}

signed main() {
#ifdef ONPC
    freopen("../a.in", "r", stdin);
//    freopen("../a.out", "w", stdout);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout << fixed;
    cout.precision(20);
    solve();
    cerr << "\n\nConsumed " << TIME << endl;
}