int solve(int input1, int input2[]) { 
    int n = input1; 
    vector<int>v(n); 
    for (int i = 0; i < n; ++i) 
    { 
        v[i] = input2[i]; 
    } 
    sort(v.begin(), v.end(), greater<int>()); 
    vector<long long>suf(n); 
    for (int i = n - 1; i >= 0; --i) 
    { 
        if (i == n - 1)suf[i] = v[i]; 
        else suf[i] += suf[i + 1] + v[i]; 
    } 
    long long res = LLONG_MIN; 
    long long sm = 0; 
    for (int i = 0; i < n; ++i) 
    { 
        long long temp = (sm * (i)) + suf[i]; 
        res = max(res, temp); 
        sm += v[i]; 
    } 
    res = max(res, sm * n); 
    return res; 
}

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>

using namespace std;

int rescueKingGeorge(int input1, int input2, vector<vector<int>>& palace) {
    pair<int, int> entrance, prison;
    for (int i = 0; i < input1; i++) {
        for (int j = 0; j < input2; j++) {
            if (palace[i][j] == 1) entrance = {i, j};
            if (palace[i][j] == 2) prison = {i, j};
        }
    }
    vector<pair<int, int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    queue<tuple<int, int, int>> q; 
    q.push({entrance.first, entrance.second, 1});
    vector<vector<bool>> visited(input1, vector<bool>(input2, false));
    visited[entrance.first][entrance.second] = true;
    while (!q.empty()) {
        auto [row, col, dist] = q.front();
        q.pop();
        if (row == prison.first && col == prison.second) {
            return dist;
        }
        for (auto [dr, dc] : directions) {
            int newRow = row + dr;
            int newCol = col + dc;
            if (newRow >= 0 && newRow < input1 && newCol >= 0 && newCol < input2 &&
                !visited[newRow][newCol] && palace[newRow][newCol] != -1) {
                visited[newRow][newCol] = true;
                q.push({newRow, newCol, dist + 1});
            }
        }
    }
    return -1;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool solve(int power, const vector<int>& benches, const vector<int>& lampPosts) {
    int n = benches.size();
    int m = lampPosts.size();
    int j = 0;  
    
    for (int i = 0; i < n; ++i) {
        while (j < m && lampPosts[j] + power < benches[i]) {
            ++j;
        }
        if (j >= m || lampPosts[j] - power > benches[i]) {
            return false;
        }
    }
    return true;
}

int findMinPower(int numBenches, int numLampPosts, vector<int>& benches, vector<int>& lampPosts) {
    sort(benches.begin(), benches.end());
    sort(lampPosts.begin(), lampPosts.end());

    int low = 0;
    int high = max(benches.back(), lampPosts.back());  
    while (low < high) {
        int mid = (low + high) / 2;
        if (solve(mid, benches, lampPosts)) {
            high = mid; 
        } else {
            low = mid + 1;  
        }
    }

    return low;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int findKthHighestDiamonds(string houses, int M, int K) {
    vector<int> diamondCounts;
    int n = houses.size();
        if (M > n) {
        return -1;
    }
    int currentDiamonds = 0;
        for (int i = 0; i < M; ++i) {
        if (houses[i] == '1') {
            currentDiamonds++;
        }
    }
        diamondCounts.push_back(currentDiamonds);
        for (int i = M; i < n; ++i) {
        if (houses[i - M] == '1') {
            currentDiamonds--;
        }
        if (houses[i] == '1') {
            currentDiamonds++;
        }
        diamondCounts.push_back(currentDiamonds);
    }
        sort(diamondCounts.begin(), diamondCounts.end(), greater<int>());
        if (K > diamondCounts.size()) {
        return -1;
    }
        return diamondCounts[K - 1];
}

#include <iostream>
#include <string>

using namespace std;

char lastOneStanding(string S, int K) {
    string concatenatedString = "";
    for (int i = 0; i < K; i++) {
        concatenatedString += S;
    }
        int removeFromStart = 1; 
    
    while (concatenatedString.length() > 1) {
        string newString = "";
        int len = concatenatedString.length();
        
        if (removeFromStart) {
            for (int i = 1; i < len; i += 2) {
                newString += concatenatedString[i];
            }
        } else {
            for (int i = len - 2; i >= 0; i -= 2) {
                newString = concatenatedString[i] + newString;
            }
        }
        
        concatenatedString = newString;
        removeFromStart = 1 - removeFromStart; 
    }
    
    return concatenatedString[0];
}

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

void find_most_frequent_ngram(const string& S, int N) {
    unordered_map<string, int> a;
    int w = 0;
    string d;

    for (int i = 0; i <= S.length() - N; ++i) {
        string ngram = S.substr(i, N);
        a[ngram]++;
        if (a[ngram] > w) {
            w = a[ngram];
            d = ngram;
        }
    }
        cout << d << " " << w << endl;
}

int main() {
    string input, S;
    int N;
    getline(cin, input);
    size_t space_pos = input.find_last_of(' ');
    S = input.substr(0, space_pos);
    N = stoi(input.substr(space_pos + 1));
    find_most_frequent_ngram(S, N);
    
    return 0;
}