/// proba sa ma asigur ca nu pica dinamica si signal 11
#include <fstream>
#include <string>

using namespace std;

ifstream in ("pavare2.in");
ofstream out ("pavare2.out");

int dp[102][2][101][101], ans[101], curent[101];

void suma (int s[], int x[], int y[])
{
    int t = 0, i;
    for (i = 1; i <= x[0] || i <= y[0]; i++)
    {
        int aux = x[i] + y[i] + t;
        s[i] = aux % 10;
        t = aux / 10;
    }
    s[0] = i - 1;
    if (t > 0)
    {
        s[++s[0]] = t;
    }
}

void dif (int d[], int x[], int y[])
{
    int t = 0;
    d[0] = x[0];
    for (int i = 1; i <= x[0]; i++)
    {
        int k = x[i] - t - y[i];
        if (x[i] - t < y[i])
        {
            k += 10;
            t = 1;
        }
        else
        {
            t = 0;
        }
        d[i] = k;
    }
    while (d[d[0]] == 0)
    {
        d[0]--;
    }
}

int cmp (int x[], int y[])
{
    if (x[0] > y[0])
    {
        return 1;
    }
    if (x[0] < y[0])
    {
        return -1;
    }
    for (int i = x[0]; i > 0; i--)
    {
        if (x[i] > y[i])
        {
            return 1;
        }
        else
        {
            return -1;
        }
    }
    return 0;
}

int main ()
{
    dp[1][0][1][0] = 1;
    dp[1][0][1][1] = 1;
    dp[1][1][1][0] = 1;
    dp[1][1][1][1] = 1;
    int n, a, b;
    string aaaaaaa;
    in >> n >> a >> b >> aaaaaaa;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            if (j == 0)
            {
                for (int k = 1; k < a; k++)
                {
                    suma(dp[i + 1][j][k + 1], dp[i + 1][j][k + 1], dp[i][j][k]);
                    suma(dp[i + 1][1 - j][1], dp[i + 1][1 - j][1], dp[i][j][k]);
                    suma(dp[i][j][0], dp[i][j][0], dp[i][j][k]);
                }
                suma(dp[i + 1][1 - j][1], dp[i + 1][1 - j][1], dp[i][j][a]);
                suma(dp[i][j][0], dp[i][j][0], dp[i][j][a]);
            }
            else
            {
                for (int k = 1; k < b; k++)
                {
                    suma(dp[i + 1][j][k + 1], dp[i + 1][j][k + 1], dp[i][j][k]);
                    suma(dp[i + 1][1 - j][1], dp[i + 1][1 - j][1], dp[i][j][k]);
                    suma(dp[i][j][0], dp[i][j][0], dp[i][j][k]);
                }
                suma(dp[i + 1][1 - j][1], dp[i + 1][1 - j][1], dp[i][j][b]);
                suma(dp[i][j][0], dp[i][j][0], dp[i][j][b]);
            }
        }
    }
    suma(ans, dp[n][0][0], dp[n][1][0]);
    for (int i = ans[0]; i > 0; i--)
    {
        out << ans[i];
    }
    out << '\n';
    curent[0] = aaaaaaa.size();
    for (int i = curent[0], j = 0; i > 0; i--, j++)
    {
        curent[i] = (aaaaaaa[j] - '0');
    }
    ans[0] = 0;
    ans[1] = 1;
    dif(curent, curent, ans);
    int culoare = 0, ct = n;
    while (ct > 0)
    {
        if (culoare == 0)
        {
            if (cmp(curent, dp[ct][0][0]) == 1)
            {
                dif(curent, curent, dp[ct][0][0]);
            }
            else
            {
                for (int i = a; i > 0; i--)
                {
                    if (cmp(dp[ct][0][i], curent) >= 0)
                    {
                        for (int j = 1; j <= i; j++)
                        {
                            out << 0;
                        }
                        ct -= i;
                        //out << '\n';
                        break;
                    }
                    else
                    {
                        dif(curent, curent, dp[ct][0][i]);
                    }
                }
            }
        }
        else
        {
            if (cmp(curent, dp[ct][1][0]) == 1)
            {
                dif(curent, curent, dp[ct][1][0]);
            }
            else
            {
                for (int i = 1; i <= b; i++)
                {
                    if (cmp(dp[ct][1][i], curent) >= 0)
                    {
                        for (int j = 1; j <= i; j++)
                        {
                            out << 1;
                        }
                        //out << '\n';
                        ct -= i;
                        break;
                    }
                    else
                    {
                        dif(curent, curent, dp[ct][1][i]);
                    }
                }
            }
        }
        culoare = 1 - culoare;
    }
    in.close();
    out.close();
    return 0;
}