func_code_string: #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;   }   