#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

ifstream fin("zero.in");
ofstream fout("zero.out");

struct Huge {
    vector < char > digi;

    Huge() { }

    Huge(int val) {
        do {
            digi.push_back(val % 10);
            val /= 10;
        } while (val);
    }

    Huge operator = (Huge aux) {
        digi.clear();

        for (int i : aux.digi)
            digi.push_back(i);

        return *this;
    }

    Huge operator + (Huge aux) {
        int T(0);
        Huge ans;

        for (int i = 0; (i < aux.digi.size() || i < digi.size()) || T != 0; ++i) {
            if (i < aux.digi.size() && i < digi.size()) {
                ans.digi.push_back((digi[i] + aux.digi[i] + T) % 10);
                T = (digi[i] + aux.digi[i] + T) / 10;
            } else if (i < aux.digi.size()) {
                ans.digi.push_back((aux.digi[i] + T) % 10);
                T = (aux.digi[i] + T) / 10;
            } else if (i < digi.size()) {
                ans.digi.push_back((digi[i] + T) % 10);
                T = (digi[i] + T) / 10;
            } else {
                ans.digi.push_back(T);
                T = 0;
            }
        }
        return ans;
    }

    Huge operator * (int oof) {///oof * 9 intra in int
        int T(0);///nu e mereu cifra
        Huge ans;

        for (int i = 0; i < digi.size() || T != 0; ++i) {
            if (i < digi.size()) {
                ans.digi.push_back((digi[i] * oof + T) % 10);
                T = (digi[i] * oof + T) / 10;
            }
            else {
                ans.digi.push_back(T % 10);
                T = T / 10;
            }
        }

        return ans;
    }

    void print() {
        for (int i = digi.size() - 1; i >= 0; --i)
            fout << (int)digi[i];
    }
};

const int N = 22;

Huge dp[N][N][N];///dp[d][s][maxs] = nr de numere in baza b de d cifre care au ultimele s cifre egale cu 0 si secventa de 0 de lungime maxima egala cu maxs

int main()
{
    int l, b, p, q;
    fin >> l >> b >> p >> q;
    dp[1][0][0] = *new Huge(b - 1);
    if (l == 1)
        dp[1][1][1] = *new Huge(1);
    for (int i = 2; i <= l; ++i) {
        for (int maxs = 0; maxs <= i; ++maxs) {
            for (int s = 0; s <= maxs; ++s) {
                ///1. ultima cifra este egala cu 0
                if (s != 0)///trebuie neaparat sa fie egal cu 0
                    dp[i][s][maxs] = dp[i - 1][s - 1][maxs] + (s == maxs ? dp[i - 1][s - 1][maxs - 1] : 0);
                else { ///if (s == 0)
                    for (int _s = 0; _s <= maxs; ++_s)
                        dp[i][s][maxs] = dp[i - 1][_s][maxs] + dp[i][s][maxs];
                    dp[i][s][maxs] = dp[i][s][maxs] * (b - 1);
                }
//                dp[i][s][maxs].print();
//                fout << '\t';
            }
//            fout << '\n';
        }
//        fout << "\n~~~~~~~~~~~~~~~~~~~~~~~~~\n";
    }
    Huge ans1, ans2;
    for (int i = 0; i <= p; ++i)
        for (int s = 0; s <= p; ++s)
            ans1 = ans1 + dp[l][s][i];
    for (int i = q; i <= l; ++i)
        for (int s = 0; s <= l; ++s)
            ans2 = ans2 + dp[l][s][i];
    ans1.print();
    fout << '\n';
    ans2.print();
    fout << '\n';
    return 0;
}