#include <iostream>
#include <string>
using namespace std;

const int MOD = 1e9 + 7;

int main() {
    int n, K;
    string R;
    cin >> n >> K >> R;
    
    if (K == 1) {
        long long result = 0;
        for (char c : R) {
            result = (result * 10 + (c - '0')) % MOD;
        }
        result = (result + 1) % MOD;
        cout << result << endl;
        return 0;
    }
 
    string binary = "";
    string current = R;
    
    while (current != "0") {
        int last_digit = current.back() - '0';
        int bit = last_digit % 2;
        binary = char('0' + bit) + binary;
        
        string next = "";
        int carry = 0;
        for (char c : current) {
            int digit = c - '0' + carry * 10;
            next += char(digit / 2 + '0');
            carry = digit % 2;
        }
        
     
        int pos = 0;
        while (pos < next.size() && next[pos] == '0') pos++;
        if (pos == next.size()) {
            current = "0";
        } else {
            current = next.substr(pos);
        }
    }
    
    if (binary.empty()) binary = "0";
    
    int L = binary.size();

    int dp[100001][2] = {0};
    int next_dp[100001][2] = {0};
    
    dp[0][1] = 1; 
    
    for (int i = 0; i < L; i++) {
        int bit = binary[i] - '0';
     
        for (int r = 0; r < K; r++) {
            next_dp[r][0] = 0;
            next_dp[r][1] = 0;
        }
        
        for (int r = 0; r < K; r++) {
           
            if (dp[r][1] > 0) {
   
                if (bit == 0) {
                    next_dp[r][1] = (next_dp[r][1] + dp[r][1]) % MOD;
                } else {
                    next_dp[r][0] = (next_dp[r][0] + dp[r][1]) % MOD;
                }
             
                if (bit == 1) {
                    int new_r = (r + 1) % K;
                    next_dp[new_r][1] = (next_dp[new_r][1] + dp[r][1]) % MOD;
                }
            }
        
            if (dp[r][0] > 0) {
    
                next_dp[r][0] = (next_dp[r][0] + dp[r][0]) % MOD;
                int new_r = (r + 1) % K;
                next_dp[new_r][0] = (next_dp[new_r][0] + dp[r][0]) % MOD;
            }
        }
        
        for (int r = 0; r < K; r++) {
            dp[r][0] = next_dp[r][0];
            dp[r][1] = next_dp[r][1];
        }
    }
    
    int answer = (dp[0][0] + dp[0][1]) % MOD;
    cout << answer;
    
    return 0;
}