For each string s consisting of characters '0' and '1' one can define four integers a00, a01, a10 and a11, where axy is the number of subsequences of length 2 of the string s equal to the sequence {x, y}. 

In these problem you are given four integers a00, a01, a10, a11 and have to find any non-empty string s that matches them, or determine that there is no such string. One can prove that if at least one answer exists, there exists an answer of length no more than 1 000 000.

Input

The only line of the input contains four non-negative integers a00, a01, a10 and a11. Each of them doesn't exceed 109.

Output

If there exists a non-empty string that matches four integers from the input, print it in the only line of the output. Otherwise, print "Impossible". The length of your answer must not exceed 1 000 000.

Examples

Input

1 2 3 4


Output

Impossible


Input

1 2 2 1


Output

0110
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

import static java.lang.Math.min;
import static java.util.Collections.binarySearch;
import static java.util.Collections.sort;

public class Solution {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int a00 = in.nextInt(), a01 = in.nextInt(), a10 = in.nextInt(), a11 = in.nextInt(), ch = a01 + a10;

        int k0 = 1, c0 = 0, k1 = 1, c1 = 0;
        while (c0 < a00) c0 += k0++;
        while (c1 < a11) c1 += k1++;

        if (c0 != a00 || c1 != a11) {
            out.println("Impossible");
            return;
        }

        int[] k_0, k_1;
        if (c0 == 0) k_0 = new int[]{1, 0};
        else k_0 = new int[]{k0};
        if (c1 == 0) k_1 = new int[]{1, 0};
        else k_1 = new int[]{k1};

        for (int i = 0; i < k_0.length; i++)
            for (int j = 0; j < k_1.length; j++) {
                k0 = k_0[i];
                k1 = k_1[j];
                if (ch == k0 * k1) {
                    while (k0 > 0 || k1 > 0)
                        if (k1 > 0 && k0 <= a10) {
                            out.print(1);
                            k1--;
                            a10 -= k0;
                        } else {
                            out.print(0);
                            k0--;
                        }
                    return;
                }
            }

        out.println("Impossible");
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Solution().run();
    }
}