#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

bool is_prime(int p) {
    int i = 2;
    while (i * i <= p) {
        if (p % i == 0)
            return false;
        ++i;
    }
    return true;
}

int nxt_prime(int x) {
    while (!is_prime(x)) {
        ++x;
    }
    return x;
}

int safe_add(int a, int b, int p) {
    if (a + b >= p)
        return a + b - p;
    return a + b;
}

int solve(const vector<string>& A, int K) {
    int n = A.size();
    const int T = 3;
    int primes[3] = {1000089401, 1000030897, 1000092791};

    vector<int> kek(K);
    vector<array<int, T>> vals(n);

    array<int, T> need;
    fill(need.begin(), need.end(), 1);
    for (int i = 0; i < K; ++i) {
        for (int t = 0; t < T; ++t)
            need[t] = (need[t] * 1ll * 10) % primes[t];
    }
    for (int t = 0; t < T; ++t)
        need[t] = safe_add(need[t], primes[t] - 1, primes[t]);
    array<int, T> need2;
    for (int t = 0; t < T; ++t)
        need2[t] = 2ll * need[t] % primes[t];


    for (int i = 0; i < n; ++i) {
        const string& s = A[i];
        fill(kek.begin(), kek.end(), 0);
        for (int j = 0; j < s.size(); ++j) {
            kek[j % K] += s[s.size() - j - 1] - '0';
        }
        for (int j = 0; j + 1 < K; ++j) {
            kek[j + 1] += kek[j] / 10;
            kek[j] %= 10;
        }
        int cur = K - 1;
        while (kek[cur] >= 10) {
            int nxt = cur + 1;
            if (nxt == K)
                nxt = 0;
            int to_add = kek[cur] / 10;
            kek[cur] %= 10;
            kek[nxt] += to_add;
            cur = nxt;
        }
        bool mx_ans = true;
        for (int j = 0; j < K; ++j)
            mx_ans = mx_ans && kek[j] == 9;
        if (mx_ans) {
            fill(kek.begin(), kek.end(), 0);
        }
        for (int t = 0; t < T; ++t) {
            for (int j = K - 1; j >= 0; --j)
                vals[i][t] = (vals[i][t] * 1ll * 10 + kek[j]) % primes[t];
        }
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = i; j < n; ++j) {
            for (int k = j; k < n; ++k) {
                bool ok = true;
                for (int t = 0; ok && t < T; ++t) {
                    int cur = safe_add(vals[i][t], safe_add(vals[j][t], vals[k][t], primes[t]), primes[t]);
                    if (cur == 0 || cur == need[t] || cur == need2[t]);
                    else
                        ok = false;
                }

                ans += ok;
            }
        }
    }
    return ans;
}

int dumb(const vector<string>& A, int K) {
    long long M = 1;
    for (int i = 0; i < K; ++i)
        M *= 10;
    --M;
    int n = A.size();
    vector<long long> B(n);
    for (int i = 0; i < n; ++i)
        B[i] = stoll(A[i]);
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = i; j < n; ++j) {
            for (int k = j; k < n; ++k)
                ans += ((B[i] + B[j] + B[k]) % M == 0);
        }
    }
    return ans;
}

//#define STRESS

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
#ifdef STRESS
    for (int _ = 0; _ < 100100; ++_) {
        int n = rand() % 6 + 1;
        int K = rand() % 18 + 1;
        vector<string> A(n);
        for (int i = 0; i < n; ++i)
            A[i] = to_string(rand());
        int ans = solve(A, K);
        int ans_dumb = dumb(A, K);
        if (ans != ans_dumb) {
            cerr << "BUG!!!\n";
            cerr << n << ' ' << K << '\n';
            for (int i = 0; i < n; ++i)
                cerr << A[i] << '\n';
            cerr << "wrong: " << ans << '\n';
            cerr << "right: " << ans_dumb << '\n' << '\n';
        }
    }
#else
    int n, K;
    cin >> n >> K;
    vector<string> A(n);
    for (int i = 0; i < n; ++i)
        cin >> A[i];
    cout << solve(A, K) << '\n';
#endif
    return 0;
}