/**
In loc sa construim multiplii lui M si sa ii verificam daca au toate cifrele 0 si 1, putem
sa generam in ordine crescatoare toate numerele cu cifrele 0 si 1 si sa verificam pe cel curent daca este multiplu de m.

1 10 11 100 101 110 111 1000 1001 ...
**/

#include <fstream>
#define DIM 2000001

using namespace std;

long long a, b, m, aux, ok;

long long cmmdc (long long a, long long b) {
    if (b == 0)
        return a;
    else
        return cmmdc(b, a%b);
}

int viz[DIM], c[DIM]; /// a*b <= 2000000 deci m <=2000000 deci resturile % m sunt intre 0 si 1999999
int parent[DIM], last[DIM];
ifstream fin ("multiplu.in");
ofstream fout("multiplu.out");

void sol (int u) {
    if (u!=0) {
        sol(parent[u]);
        fout<<last[u];
    }
}

int main () {

    fin>>a>>b;
    m = a/cmmdc(a,b)*b;

    c[1] = 1;
    last[1] = 1;
    parent[1] = 0;
    viz[1] = 1; /// marcam toate resturile puse in coada si nu permitem sa punem din nou acelasi rest pentru ca am obtine acelasi lucru ca si la prima intalnire
    int p = 1;
    int u = 1;

    while (p <= u) {
        /// c[p] este elementul din fata cozii si "vecinii" lui sunt c[p]*10 si c[p]*10 + 1
        for (int i=0; i<=1; i++) {
            int next = (c[p]*10 + i) % m;
            if (viz[next] == 0) {
                u ++;
                c[u] = next;
                viz[next] = 1;
                /// aici as verifica daca next este multiplu de m.
                /// problema este ca valori next prea mari nu pot memora si e intuitiv ca la numere
                /// cum sunt a si b, multiplii cmmmc-u care se obtin prin produs, cresc foarte repede
                last[u] = i; /// care a fost ultima cifra folosita pentru a obtine acest rest ?
                parent[u] = p; /// din ce element l-am obtinut pe cel curent ?

                if (next == 0) {
                    sol(u);
                    return 0;
                }
            }
        }
        p++;
    }
}

/// (m * ceva + rest) % m = rest % m