/**
Schmbam abordarea:
in loc sa construim multiplii lui m (care nu pot fi memorati)
vom construi toate numerele cu 0 si 1 si verificam la fiecare daca este multiplu al lui m.
1  2  3   4  5   6   7    8    9   10    11
1 10 11 100 101 110 111 1000 1001 1010 1011 ...
**/

#include <fstream>
#define DIM 2000001
using namespace std;

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

ifstream fin ("multiplu.in");
ofstream fout("multiplu.out");
int last[DIM], parent[DIM], c[DIM];
int viz[DIM];
long long cmmdc (long long a, long long b) {
    if (b == 0)
        return a;
    else
        return cmmdc(b, a%b);
}

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

int main () {


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


    /**
    sa tinem in coada valorile efective ne duce tor la unele nememorabile.
    vom tine insa in coada resturile impartirii acelor valori la m

    in coada fiind resturi la impartirea la m, si a*b fiind maxim 2 milioame
    inseamna ca in coada pot ajunge maxim 2 milioane de valori (deoarece nu pun un rest de 2 ori
    penru ca as obtine in continuare acelasi lucru ca si la prima plasare, iar prima plasare
    corespunde unei valori mai mici, caci, imaginandu-mi ca adaug cifra cu cifra, obtin numerele in ordine
    crescatoare)

    **/

    c[1] = 1; /// plecam de la numarul 1
    last[1] = 1;
    parent[1] = 0;
    p = 1;
    u = 1;
    viz[1] = 1;
    while (p <= u) {
        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;
                last[u] = i; /// tinem minte ce cifra am folosit ultima data pentru a obtine restul de pe pozitia i
                parent[u] = p;

                if (next == 0) {
                    /// am gasit o solutie
                    /// problema este ca in coada am doar niste resturi % m nu valorile efective
                    /// dar eu am nevoie de valorile efective cu 0 si 1

                    /// ma folosesc de vectorii last si parent pentru a construi rezultatul invers cifra cu cifra
                    sol(u);

                }

            }
        }

        p++;
    }

    return 0;
}