Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.

The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!

Input

The first line contains two integers, n and k (0 ≤ k < n ≤ 105).

The second line contains a string consisting of n digits.

Output

Print the answer to the problem modulo 109 + 7.

Examples

Input

3 1
108


Output

27

Input

3 2
108


Output

9

Note

In the first sample the result equals (1 + 08) + (10 + 8) = 27.

In the second sample the result equals 1 + 0 + 8 = 9.
#include <bits/stdc++.h>
const int mod = 1000000007;
const int gmod = 3;
const int inf = 1039074182;
const double eps = 1e-9;
const long long llinf = 2LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
  if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
  if (b > x) x = b;
}
inline void chadd(int &x, int b) {
  x += b - mod;
  x += (x >> 31 & mod);
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
  x += b;
  if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
  x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
  x %= b, x += b;
  if (x >= b) x -= b;
}
template <typename T>
inline T mabs(T x) {
  return (x < 0 ? -x : x);
}
using namespace std;
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, vector<T> vec) {
  cout << "{";
  for (int i = 0; i < (int)vec.size(); i++) {
    cout << vec[i];
    if (i != (int)vec.size() - 1) cout << ',';
  }
  cout << "}";
  return cout;
}
template <typename T>
void operator*=(vector<T> &vec, int k) {
  for (auto &x : vec) x *= k;
}
template <typename T>
void operator-=(vector<T> &a, const vector<T> &b) {
  assert(a.size() == b.size());
  for (size_t it = 0; it < a.size(); it++) {
    a[it] -= b[it];
  }
}
template <typename T>
vector<T> operator*(const vector<T> &vec, int k) {
  vector<T> res(vec);
  res *= k;
  return res;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
  cout << "(" << p.first << ',' << p.second << ")";
  return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
  vector<T> t;
  for (auto x : s) t.push_back(x);
  cout << t;
  return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, multiset<T, T2> s) {
  vector<T> t;
  for (auto x : s) t.push_back(x);
  cout << t;
  return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
  vector<T> t;
  while (q.size()) {
    t.push_back(q.front());
    q.pop();
  }
  cout << t;
  return cout;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &cout, map<T1, T2, T3> m) {
  for (auto &x : m) {
    cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
  }
  return cout;
}
template <typename T>
T operator*(vector<T> v1, vector<T> v2) {
  assert(v1.size() == v2.size());
  int n = v1.size();
  T res = 0;
  for (int i = 0; i < n; i++) {
    res += v1[i] * v2[i];
  }
  return res;
}
template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, const pair<T1, T2> y) {
  x.first += y.first;
  x.second += y.second;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &x, const pair<T1, T2> &y) {
  return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &x, const pair<T1, T2> &y) {
  return make_pair(x.first - y.first, x.second - y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
  return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T>> operator~(vector<vector<T>> vec) {
  vector<vector<T>> v;
  int n = vec.size(), m = vec[0].size();
  v.resize(m);
  for (int i = 0; i < m; i++) {
    v[i].resize(n);
  }
  for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
      v[i][j] = vec[j][i];
    }
  }
  return v;
}
void print0x(int x) {
  std::vector<int> vec;
  while (x) {
    vec.push_back(x & 1);
    x >>= 1;
  }
  std::reverse(vec.begin(), vec.end());
  for (int i = 0; i < (int)vec.size(); i++) {
    std::cout << vec[i];
  }
  std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
  std::vector<int> vec;
  while (x) {
    vec.push_back(x & 1);
    x >>= 1;
  }
  reverse(vec.begin(), vec.end());
  for (int i = (int)vec.size(); i < len; i++) {
    putchar('0');
  }
  for (size_t i = 0; i < vec.size(); i++) {
    std::cout << vec[i];
  }
  std::cout << ' ';
}
template <int mod>
struct ModInt {
  int x;
  ModInt() { x = 0; }
  ModInt(int _x) {
    x = _x % mod;
    if (x < 0) x += mod;
  }
  ModInt(long long _x) {
    x = _x % mod;
    if (x < 0) x += mod;
  }
  ModInt<mod> &operator++() {
    ++x;
    if (x == mod) x = 0;
    return *this;
  }
  ModInt<mod> operator++(int) {
    int t = x;
    x++;
    if (x == mod) x = 0;
    return t;
  }
  ModInt<mod> &operator--() {
    --x;
    if (x == -1) x += mod;
    return *this;
  }
  ModInt<mod> operator--(int) {
    int t = x;
    x--;
    if (x == -1) x += mod;
    return t;
  }
};
template <int mod>
inline int mabs(const ModInt<mod> &a) {
  return a.x;
}
template <int mod>
bool operator==(const ModInt<mod> &a, const ModInt<mod> &b) {
  return a.x == b.x;
}
template <int mod>
bool operator==(ModInt<mod> a, int x) {
  return (a.x == x);
}
template <int mod>
bool operator!=(const ModInt<mod> &a, const ModInt<mod> &b) {
  return (a.x != b.x);
}
template <int mod>
bool operator!=(ModInt<mod> a, int x) {
  return (a.x != x);
}
template <int mod>
ModInt<mod> operator+(ModInt<mod> a, int b) {
  a.x += b;
  if (a.x >= mod) a.x -= mod;
  return a;
}
template <int mod>
ModInt<mod> operator+(ModInt<mod> a, ModInt<mod> b) {
  int tmp = a.x + b.x;
  if (tmp >= mod) tmp -= mod;
  return tmp;
}
template <int mod>
ModInt<mod> operator-(ModInt<mod> a, ModInt<mod> b) {
  int tmp = a.x - b.x;
  if (tmp < 0) tmp += mod;
  return tmp;
}
template <int mod>
ModInt<mod> operator-(ModInt<mod> a, int b) {
  return a - (ModInt<mod>)b;
}
template <int mod>
void operator-=(ModInt<mod> &a, ModInt<mod> b) {
  a.x -= b.x;
  a.x += (a.x >> 31 & mod);
}
template <int mod, typename T>
void operator-=(ModInt<mod> &a, const T &b) {
  a.x -= b;
  a.x += (a.x >> 31 & mod);
}
template <int mod>
ModInt<mod> operator*(ModInt<mod> a, ModInt<mod> b) {
  return 1LL * a.x * b.x % mod;
}
template <int mod>
ModInt<mod> operator*(ModInt<mod> a, int b) {
  return 1LL * a.x * b % mod;
}
template <int mod>
void operator*=(ModInt<mod> &a, ModInt<mod> b) {
  a = a * b;
}
template <int mod, typename T>
void operator*=(ModInt<mod> &a, const T &b) {
  a = a * b;
}
template <int mod>
void operator+=(ModInt<mod> &a, ModInt<mod> b) {
  a.x += b.x;
  if (a.x >= mod) a.x -= mod;
}
template <int mod, typename T>
void operator+=(ModInt<mod> &a, const T &b) {
  a.x += b;
  if (a.x >= mod) a.x -= mod;
}
template <int mod>
inline ModInt<mod> inv(ModInt<mod> x) {
  int m = mod - 2;
  ModInt<mod> basic = x;
  x = 1;
  while (m) {
    if (m & 1) x *= basic;
    m >>= 1;
    basic *= basic;
  }
  return x;
}
template <int mod>
ModInt<mod> operator/(ModInt<mod> a, ModInt<mod> b) {
  return a * inv(b);
}
template <int mod>
ModInt<mod> operator/(ModInt<mod> a, int b) {
  return a * inv((ModInt<mod>)b);
}
template <int mod>
void operator/=(ModInt<mod> &a, int b) {
  a *= inv(ModInt<mod>(b));
}
template <int mod>
void operator/=(ModInt<mod> &a, ModInt<mod> b) {
  a = a / b;
}
template <int mod>
ModInt<mod> operator^(ModInt<mod> basic, int x) {
  ModInt<mod> res = 1;
  while (x) {
    if (x & 1) res *= basic;
    basic *= basic;
    x >>= 1;
  }
  return res;
}
template <int mod>
istream &operator>>(istream &cin, ModInt<mod> &x) {
  cin >> x.x;
  x.x %= mod;
  if (x.x < 0) x.x += mod;
  return cin;
}
template <int mod>
ostream &operator<<(ostream &cout, ModInt<mod> x) {
  cout << x.x;
  return cout;
}
namespace combinatorics {
int *fac;
int *ifac;
int __Tmod;
inline int add(int a, int b) { return (a + b) % __Tmod; }
inline int sub(int a, int b) { return (a - b + __Tmod) % __Tmod; }
inline int mult(int a, int b) { return (1LL * a * b) % __Tmod; }
inline int fastpow(int basic, int x) {
  chmod(x, __Tmod - 1);
  if (x == 0) return 1;
  int res = 1;
  while (x) {
    if (x & 1) res = mult(res, basic);
    basic = mult(basic, basic);
    x >>= 1;
  }
  return res;
}
inline int inv(int x) { return fastpow(x, __Tmod - 2); }
inline int div(int a, int b) { return mult(a, inv(b)); }
void init(int n, int tmod) {
  __Tmod = tmod;
  fac = new int[n + 5];
  ifac = new int[n + 5];
  fac[0] = 1;
  for (int i = 1; i <= n; i++) {
    fac[i] = mult(fac[i - 1], i);
  }
  ifac[n] = inv(fac[n]);
  for (int i = n - 1; i >= 0; i--) {
    ifac[i] = mult(ifac[i + 1], i + 1);
  }
}
inline int C(int n, int m) {
  if (n < m || n < 0 || m < 0) return 0;
  return mult(mult(fac[n], ifac[m]), ifac[n - m]);
}
inline int Cat(int x) { return mult(C(x * 2, x), inv(x + 1)); }
}  // namespace combinatorics
using namespace std;
using Int = ModInt<mod>;
int n, k;
char c[100005];
Int sum[100005];
Int a[100005];
int main() {
  scanf("%d%d", &n, &k);
  scanf("%s", c);
  for (int i = 0; i < n; i++) c[i] -= '0';
  combinatorics::init(n, mod);
  for (int i = 0; i < n; i++) {
    a[i] = c[i];
    sum[i] = a[i] + (i ? sum[i - 1] : 0);
  }
  Int res = 0;
  for (int j = 0; j <= n - 2; j++) {
    Int b = Int(combinatorics::C(n - j - 2, k - 1)) * (Int(10) ^ j);
    res += b * sum[n - j - 2];
  }
  for (int i = 0; i < n; i++) {
    res += a[i] * combinatorics::C(i, k) * (Int(10) ^ (n - 1 - i));
  }
  cout << res << endl;
  return 0;
}
