/**
 * @author n685
 * @brief
 * @date 2024-11-02 10:54:24
 *
 *
 */
#include "bits/stdc++.h"

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbg_proj(...) 420
#define dbg_rproj(...) 420420
void nline() {}
void bar() {}
void start_clock() {}
void end_clock() {}
#endif

namespace rs = std::ranges;
namespace rv = std::views;

namespace multihash {

template <class T> constexpr std::pair<T, T> ex_eucl(T a, T b) {
  if (a < b) {
    auto [x, y] = ex_eucl(b, a);
    return {y, x};
  }
  if (b == 0) {
    assert(a == 1);
    return {1, 0};
  }
  auto [x, y] = ex_eucl(b, a % b);
  return {y, x - (a / b) * y};
}

template <int NUM> struct MultiHash {
  static constexpr int MAX = 1'000'000'007;
  // static inline const std::array<int, NUM> mods = []() {
  //   std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
  //   std::uniform_int_distribution<int> rnd(10000, MAX);
  //   std::array<int, NUM> ans{};
  //   for (int& v : ans) {
  //     v = rnd(rng);
  //   }
  //   return ans;
  // }();
  static inline const std::array<int, NUM> mods{1'000'000'007, 1'000'000'009, 998'244'353};
  template <class T> static constexpr T normalize(std::integral auto val, T mod) {
    using U = decltype(mod + val);
    U uval = static_cast<U>(val);
    U umd = static_cast<U>(mod);
    if (uval <= -umd || umd <= uval) {
      uval %= umd;
    }
    if (val < 0) {
      uval += umd;
    }
    return static_cast<T>(uval);
  }

  std::array<int, NUM> vals{};
  MultiHash() = default;
  explicit MultiHash(std::integral auto val) {
    for (int i = 0; i < NUM; ++i) {
      vals[i] = normalize(val, mods[i]);
    }
  }
  MultiHash& operator+=(const MultiHash& rhs) {
    for (int i = 0; i < NUM; ++i) {
      vals[i] += rhs.vals[i];
      if (vals[i] >= mods[i]) {
        vals[i] -= mods[i];
      }
    }
    return *this;
  }
  friend MultiHash operator+(MultiHash lhs, const MultiHash& rhs) { return lhs += rhs; }
  MultiHash& operator-=(const MultiHash& rhs) {
    for (int i = 0; i < NUM; ++i) {
      vals[i] -= rhs.vals[i];
      if (vals[i] < 0) {
        vals[i] += mods[i];
      }
    }
    return *this;
  }
  MultiHash operator-() const {
    MultiHash ans;
    for (int i = 0; i < NUM; ++i) {
      ans.vals[i] = normalize(-vals[i], mods[i]);
    }
    return ans;
  }
  friend MultiHash operator-(MultiHash lhs, const MultiHash& rhs) { return lhs -= rhs; }
  MultiHash& operator*=(const MultiHash& rhs) {
    for (int i = 0; i < NUM; ++i) {
      vals[i] = static_cast<int>(int64_t{vals[i]} * rhs.vals[i] % mods[i]);
    }
    return *this;
  }
  friend MultiHash operator*(MultiHash lhs, const MultiHash& rhs) { return lhs *= rhs; }

  MultiHash binpow(std::integral auto b) const {
    MultiHash res{1}, a = *this;
    while (b > 0) {
      if (b % 2 == 1) {
        res *= a;
      }
      a *= a;
      b /= 2;
    }
    return res;
  }
  MultiHash inv() const {
    MultiHash ans;
    for (int i = 0; i < NUM; ++i) {
      ans.vals[i] = normalize(ex_eucl<int64_t>(vals[i], mods[i]).first);
    }
    return ans;
  }
  bool operator==(const MultiHash& rhs) const = default;
  auto operator<=>(const MultiHash& rhs) const = default;
};

} // namespace multihash

using Hash = multihash::MultiHash<3>;
constexpr int MX = 10;

int main() {
#ifndef LOCAL
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
#endif

  const std::array<Hash, MX + 1> digits = []() {
    std::array<Hash, MX + 1> ans{};
    for (int i = 0; i <= 10; ++i) {
      ans[i] = Hash{i};
    }
    return ans;
  }();

  int n, k;
  std::cin >> n >> k;

  std::vector<int> m(k, 9);
  Hash hm;
  for (int j : m | rv::reverse) {
    hm = digits[10] * hm + Hash{j};
  }

  std::vector<Hash> a(n);
  for (int i = 0; i < n; ++i) {
    std::vector<int> v;
    std::string s;
    std::cin >> s;
    for (char c : s) {
      v.push_back(c - '0');
    }
    rs::reverse(v);
    while (std::ssize(v) > k) {
      std::vector<int> nv(k);
      for (int j = 0; j < std::ssize(v); ++j) {
        nv[j % k] += v[j];
      }
      for (int j = 0; j < std::ssize(nv); ++j) {
        if (nv[j] >= 10) {
          if (j == std::ssize(nv) - 1) {
            nv.push_back(0);
          }
          nv[j + 1] += nv[j] / 10;
          nv[j] %= 10;
        }
      }
      v.swap(nv);
    }
    if (v == m) {
      v = {};
    }
    for (int j : v | rv::reverse) {
      a[i] = digits[10] * a[i] + Hash{j};
    }
  }
  std::map<Hash, int> freq;
  int ans = 0;
  Hash hm2 = digits[2] * hm;
  for (int i = 0; i < n; ++i) {
    ++freq[a[i]];
    for (int j = i; j < n; ++j) {
      Hash sum = a[i] + a[j];
      if (freq.contains(-sum)) {
        ans += freq[-sum];
      }
      if (freq.contains(hm - sum)) {
        ans += freq[hm - sum];
      }
      if (freq.contains(hm2 - sum)) {
        ans += freq[hm2 - sum];
      }
    }
  }
  std::cout << ans << '\n';
}