#include <fstream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;

ifstream cin("bile2.in");
ofstream cout("bile2.out");

const int MAXN = 1010;
const int BASE = 1000000000;
const int BASE_DIGITS = 9;

class Huge {
    public:
        Huge() {
            v.resize(100, 0);
        }

        void operator = (int value) {
            v[0] = 0;
            while (value) {
                v[0]++;
                v[v[0]] = value % BASE;
                value /= BASE;
            }
        }

        void operator = (char *s) {
            v[0] = 0;
            for (int i = strlen(s); i > 0; i -= BASE_DIGITS) {
                v[0]++;
                for (int j = max(0, i - BASE_DIGITS); j < i; j++)
                    v[v[0]] = v[v[0]] * 10 + s[j] - '0';
            }
        }

        void operator = (const Huge &other) {
            for (int i = 0; i < 100; i++)
                v[i] = other[i];
        }

        int operator [] (int index) const {
            return v[index];
        }

        int& operator [] (int index) {
            return v[index];
        }

        bool operator < (const Huge &other) {
            if (v[0] != other[0])
                return v[0] < other[0];
            for (int i = v[0]; i > 0; i--) {
                if (v[i] < other[i])
                    return true;
                if (v[i] > other[i])
                    return false;
            }
            return true;
        }

        Huge operator + (const Huge &other) {
            int i, add = 0;
            Huge answer;
            for (i = 1; i <= v[0] || i <= other[0] || add; i++, add /= BASE) {
                add += v[i] + other[i];
                answer[i] = add % BASE;
            }
            answer[0] = i - 1;
            return answer;
        }

        Huge operator - (const Huge &other) {
            Huge answer = *this;
            int i, add = 0;
            for (i = 1; i <= v[0]; i++) {
                answer[i] -= (other[i] + add);
                add = 0;
                if (answer[i] < 0) {
                    answer[i] += BASE;
                    add = 1;
                }
            }
            while (answer[0] > 1 && answer[answer[0]] == 0)
                answer[0]--;
            return answer;
        }

        Huge operator * (int value) {
            Huge answer = *this;
            int add = 0;
            for (int i = 1; i <= answer[0]; i++) {
                answer[i] = answer[i] * value + add;
                add = answer[i] / BASE;
                answer[i] %= BASE;
            }
            while (add) {
                answer[0]++;
                answer[answer[0]] = add % BASE;
                add /= BASE;
            }
            return answer;
        }

        Huge operator * (const Huge &other) {
            Huge answer;
            for (int i = 1; i <= v[0]; i++) {
                long long add = 0;
                int j;
                for (j = 1; j <= other[0] || add; j++, add /= BASE) {
                    add += answer[i + j - 1] + 1LL * v[i] * other[j];
                    answer[i + j - 1] = add % BASE;
                }
                if (i + j - 2 > answer[0])
                    answer[0] = i + j - 2;
            }
            return answer;
        }

        Huge operator / (int value) {
            Huge answer;
            long long offset = 0;
            for (int i = v[0]; i >= 1; i--) {
                offset = offset * BASE + v[i];
                answer[i] = offset / value;
                offset %= value;
            }
            while (answer[0] > 1 && answer[answer[0]] == 0)
                answer[0]--;
            return answer;
        }

        int operator % (int value) {
            long long offset = 0;
            for (int i = v[0]; i >= 1; i--) {
                offset = offset * BASE + v[i];
                offset %= value;
            }
            return offset;
        }

    private:
        vector<int> v;
};

char s[MAXN];
Huge combinations[2][MAXN], dp[2][MAXN];

ostream &operator << (ostream &output, const Huge &v) {
    if (v[0] == 0) {
        output << 0;
        return output;
    }
    output << v[v[0]];
    for (int i = v[0] - 1; i >= 1; i--) {
        int j = BASE / 10;
        while (j > v[i] && j > 1) {
            output << 0;
            j /= 10;
        }
        output << v[i];
    }
    return output;
}

int main() {
    int n, dMax;
    Huge a, b, c, d, x, y;
    cin >> n >> dMax;
    cin >> s;
    a = s;
    cin >> s;
    b = s;
    int before = 0, now = 1;
    combinations[before][0] = 1;
    combinations[before][1] = 1;
    Huge pisat;
    pisat = combinations[before][0];
    for (int i = 2; i <= n; i++) {
        combinations[now][0] = 1;
        for (int j = 1; j <= i; j++)
            combinations[now][j] = combinations[before][j - 1] + combinations[before][j];
        before ^= 1;
        now ^= 1;
    }
    int which = before;
    before = 0;
    now = 1;
    for (int i = 1; i <= n; i++)
        dp[before][i] = i;
    for (int i = 2; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (j > dMax + 1)
                dp[now][j] = dp[before][j - dMax - 1];
            else
                dp[now][j] = 0;
            dp[now][j] = dp[now][j] + dp[now][j - 1];
        }
        c = combinations[which][i] - dp[now][n];
        d = combinations[which][i];
        x = a * d;
        y = b * c;
        if (x < y) {
            Huge answer;
            answer = i;
            cout << answer << "\n";
            return 0;
        }
        now ^= 1;
        before ^= 1;
    }
    return 0;
}