#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#include <experimental/iterator>
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

string Add(string a, string b) {
  debug(a, "+", b);
  //ranges::reverse(a);
  //ranges::reverse(b);
  while (a.size() < max(a.size(), b.size()))
      a += "0";
  while (b.size() < max(a.size(), b.size()))
      b += "0";
  int cur = 0;
  for (int i = 0; i < ssize(a); ++i) {
    cur += a[i] - '0';
    cur += b[i] - '0';
    a[i] = cur % 10 + '0';
    cur /= 10;
  }
  if (cur)
    a.push_back('0' + cur);
  //ranges::reverse(a);
  debug(a);
  return a;
}

string Mod(string s, int k) {
  if (ssize(s) < k)
    return s;
  if (ssize(s) == k) {
    bool all9 = true;
    for (auto c : s)
      all9 &= c == '9';
    if (all9)
      return "0";
    return s;
  }
  ranges::reverse(s);
  string ret = s.substr(0, k);
  for (int i = k; i < ssize(s); i += k) {
    int l = min<int>(k, ssize(s) - i);
    auto cur = Add(ret, s.substr(i, l));
    ranges::reverse(cur);
    ret = Mod(cur, k);
    ranges::reverse(ret);
  }
  ranges::reverse(ret);
  return ret;
}

constexpr int K = 3;
constexpr int64_t MODS[K] = {1000005863, 1000009601, 1000006393};

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n, m;
  cin >> n >> m;
  vector<string> a(n);
  for (auto &ai : a) {
    cin >> ai;
    ai = Mod(ai, m);
    debug(ai);
  }

  vector<array<int, K>> v;
  for (auto ai : a) {
    array<int, K> cur = {};
    for (int k = 0; k < K; ++k) {
      for (auto c : ai)
        cur[k] = (cur[k] * 10LL + c - '0') % MODS[k];
    }
    v.push_back(cur);
  }

  for (auto x : v) {
    orange(all(x));
  }

  array<array<int, K>, 3> tar = {};

  array<int, K> M;
  M.fill(1);
  for (int i = 0; i < m; ++i) {
    for (int k = 0; k < K; ++k)
      M[k] = (M[k] * 10LL) % MODS[k];
  }
  for (int k = 0; k < K; ++k) {
    M[k] = (M[k] + MODS[k] - 1) % MODS[k];
  }
  tar[1] = M;
  for (int k = 0; k < K; ++k) {
    M[k] = (M[k] + M[k]) % MODS[k];
  }
  tar[2] = M;

  int ans = 0;
  for (int i = 0; i < n; ++i) {
    debug(i);
    map<array<int, K>, int> cnt;
    for (int j = i; j < n; ++j) {
      auto cur = v[j];
      for (int k = 0; k < K; ++k) {
        cur[k] = (cur[k] + v[i][k] + MODS[k]) % MODS[k];
      }
      cnt[cur] += 1;
      debug("add", i, j);
      //orange(all(cur));

      for (int t = 0; t < 3; ++t) {
        auto que = tar[t];
        for (int k = 0; k < K; ++k)
          que[k] = (que[k] + MODS[k] - v[j][k]) % MODS[k];
        //debug("que", t, j);
        //orange(all(que));
        auto it = cnt.find(que);
        if (it != cnt.end() and it->second) {
          debug("que", t, j, it->second);
          orange(all(que));
          debug(it->second);
          ans += it->second;
        }
      }
    }
  }
  cout << ans << '\n';
  return 0;
}