#pragma GCC optimize("Ofast")

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb emplace_back
#define AI(i) begin(i), end(i)
template<class T> bool chmin(T &a, T b) { return b < a && (a = b, true); }
template<class T> bool chmax(T &a, T b) { return a < b && (a = b, true); }
#ifdef KEV
#define DE(args...) kout("[ " + string(#args) + " ] = ", args)
void kout() { cerr << endl; }
template<class T, class ...U> void kout(T a, U ...b) { cerr << a << ' ', kout(b...); }
template<class T> void debug(T l, T r) { while (l != r) cerr << *l << " \n"[next(l)==r], ++l; }
#else
#define DE(...) 0
#define debug(...) 0
#endif

const int MAX_N = 20001, inf = 1e9 + 10, MAX_1 = 25, MAX_MOD = 500;

// M is cnt0, N is cnt1
int m, n, k, R;

//     cnt1   cnt0 , mod
int dp[MAX_1][MAX_N][MAX_MOD], modv[MAX_N << 1];

void add(int &a, int b) { a = min(inf, a + b); }

// cause cnt0 is so small
// dp[ cnt0 ][ cnt1 ][ mod ]
int bfsolve() {
    modv[0] = 1;
    for (int i = 1;i <= n + m;++i)
        modv[i] = modv[i-1] * 2 % k;

    dp[0][0][0] = 1;

    for (int i = 0;i <= m;++i)
        for (int j = 0;j <= n;++j) {

            for (int mv = 0;mv < k;++mv) if (dp[i][j][mv]) {
                //DE(i, j, mv, dp[i][j][mv]);
                add(dp[i][j+1][ (modv[i+j] + mv) % k],  dp[i][j][mv]);
                add(dp[i+1][j][ mv ], dp[i][j][mv]);
            }


        }

    int l0 = m, l1 = n-1, cmod = (k - modv[l0 + l1]) % k;

    string res = "1";

    if (dp[l0][l1][cmod] < R) return puts("impossible"), 0;

    for (int len = l0 + l1 - 1;len >= 0;--len) {
        //DE(R, l0, l1, cmod, dp[l1][l0][cmod]);

        int way0 = 0, way1 = 0;
        if (l0) {
            way0 = dp[l0-1][l1][cmod];
        }
        if (l1) {
            int nmod = (cmod + k - modv[len]) % k;
            way1 = dp[l0][l1-1][nmod];
        }

        //DE(way0, way1);

        if (way1 >= R) {
            res.push_back('1');
            cmod = (cmod + k - modv[len]) % k;
            --l1;
        }
        else {
            R -= way1;
            res.push_back('0');
            --l0;
        }
    }

    cout << res << '\n';

    return 0;
}
int32_t main() {
    ios_base::sync_with_stdio(0), cin.tie(0);

    DE(sizeof(dp) / 1000000);

    cin >> m >> n >> k >> R;

    if (m < MAX_1) {
        bfsolve();
        return 0;
    }

    modv[0] = 1;
    for (int i = 1;i <= n + m;++i)
        modv[i] = modv[i-1] * 2 % k;

    dp[0][0][0] = 1;


    int lim = min(n, MAX_1 - 2);

    for (int i = 0;i <= lim;++i)
        for (int j = 0;j <= m;++j) {

            for (int mv = 0;mv < k;++mv) if (dp[i][j][mv]) {
                DE(i, j, mv, dp[i][j][mv]);
                add(dp[i+1][j][ (modv[i+j] + mv) % k],  dp[i][j][mv]);
                add(dp[i][j+1][ mv ], dp[i][j][mv]);
            }


        }

    int l0 = m, l1 = n-1, cmod = (k - modv[l0 + l1]) % k;

    string res = "1";

    while (l1 > lim) {
        res.push_back('1');
        cmod = (cmod + k - modv[l0 + l1 - 1]) % k;
        --l1;
    }

    if (dp[l1][l0][cmod] < R) return puts("impossible"), 0;
    DE(dp[l1][l0][cmod]);

    for (int len = l0 + l1 - 1;len >= 0;--len) {
        DE(R, l0, l1, cmod, dp[l1][l0][cmod]);

        int way0 = 0, way1 = 0;
        if (l0) {
            way0 = dp[l1][l0-1][cmod];
        }
        if (l1) {
            int nmod = (cmod + k - modv[len]) % k;
            way1 = dp[l1-1][l0][nmod];
        }

        DE(way0, way1);

        if (way1 >= R) {
            res.push_back('1');
            cmod = (cmod + k - modv[len]) % k;
            --l1;
        }
        else {
            R -= way1;
            res.push_back('0');
            --l0;
        }
    }

    cout << res << '\n';
}