//#include <fstream>
//#include <cstring>
//#include <algorithm>
//using namespace std;
//ifstream in("next.in");
//ofstream out("next.out");
//const int max_digits=1e6+10;
//const int base=10;
//const int nmax=1e6+10;
//char s[nmax];
//class hugenr
//{
//public:
//    short x[max_digits];
//public:
//    hugenr()
//    {
//        memset(x,0,sizeof(x));
//        x[0]=1;
//    }
//    hugenr(long long n)
//    {
//        memset(x,0,sizeof(x));
//        x[0]=0;
//        do
//        {
//            x[++x[0]]=n%base;
//            n/=base;
//        }
//        while(n);
//    }
//    hugenr(char *s)
//    {
//        int l;
//        l=strlen(s);
//        memset(x,0,sizeof(x));
//        x[0]=l;
//        for(int i=l-1;i>=0;i--)
//            x[l-i]=s[i]-'0';
//    }
//    void print()
//    {
//        for(int i=x[0]; i>=1; i--)
//            out<<x[i];
//        out<<"\n";
//    }
//    hugenr operator +(const hugenr &other);
//    hugenr operator -(const hugenr &other);
//    hugenr operator *(int k);
//    hugenr operator /(long long k);
//    long long operator %(long long k);
//};
//hugenr hugenr :: operator +(const hugenr &other)
//{
//    int i,tr,aux;
//    hugenr c;
//    c.x[0]=max(x[0],other.x[0]);
//    for(tr=0,i=1; i<=c.x[0]; i++)
//    {
//        aux=x[i]+other.x[i]+tr;
//        c.x[i]=aux%base;
//        tr=aux/base;
//    }
//    if(tr)
//        c.x[++c.x[0]]=tr;
//    return c;
//}
//hugenr hugenr :: operator -(const hugenr &other)
//{
//    hugenr c;
//    c.x[0]=max(x[0],c.x[0]);
//    int i,impr,aux;
//    for(impr=0,i=1; i<=c.x[0]; i++)
//    {
//        aux=x[i]-other.x[i]-impr;
//        if(aux<0)
//        {
//            c.x[i]=aux+base;
//            impr=1;
//        }
//        else
//        {
//            c.x[i]=aux;
//            impr=0;
//        }
//    }
//    while(c.x[0]>1  &&  c.x[c.x[0]]==0)
//        c.x[0]--;
//    return c;
//}
//hugenr hugenr :: operator *(int k)
//{
//    hugenr c;
//    int i,aux,tr;
//    c.x[0]=x[0];
//    for(i=1; i<=c.x[0]; i++)
//        c.x[i]=x[i]*k;
//    for(tr=0,i=1; i<=c.x[0]; i++)
//    {
//        aux=c.x[i]+tr;
//        c.x[i]=aux%base;
//        tr=aux/base;
//    }
//    while(tr)
//    {
//        c.x[++c.x[0]]=tr%base;
//        tr/=base;
//    }
//    return c;
//}
//hugenr hugenr :: operator /(long long k)
//{
//    hugenr c;
//    int i;
//    long long r;
//    c.x[0]=x[0];
//    for(r=0,i=c.x[0]; i>=1; i--)
//    {
//        r=1ll*(r*base+x[i]);
//        c.x[i]=r/k;
//        r=1ll*(r%k);
//    }
//    while(c.x[0]>1  &&  c.x[c.x[0]]==0)
//        c.x[0]--;
//    return c;
//}
//long long hugenr :: operator %(long long k)
//{
//    int i;
//    long long r;
//    for(r=0,i=x[0]; i>=1; i--)
//        r=(r*base+x[i])%k;
//    return r;
//}
//int main()
//{
//    in.getline(s,nmax);
//    //hugenr nr;
//    int n,i;
//    long long d,r;
//    in>>d;
//    hugenr nr(s);
////    n=strlen(s);
////    nr.x[0]=n;
////    for(i=0; i<n; i++)
////        nr.x[n-i]=s[i]-'0';
//    r=nr%d;
//    if(r==0)
//        nr.print();
//    else
//    {
//        out<<d-r;
//        long long aux2;
//        aux2=d-r;
//        hugenr k(aux2);
//        nr=nr+k;
//        nr.print();
//    }
//    return 0;
//}
#include <fstream>
#include <algorithm>
#include <cstring>

using namespace std;
ifstream fin("next.in");
ofstream fout("next.out");
const int MAXDIGITS = 1000005;
const int BASE = 10;
char s[MAXDIGITS];
class HUGE
{
private:
    int x[MAXDIGITS];
public:
    void print()
    {
        for(int i=x[0]; i>0; i--)
            fout << x[i];
        fout << '\n';
    }
    HUGE (char s[MAXDIGITS])
    {
        int n, i;
        memset(x, 0, sizeof(x));
        n=strlen(s);
        x[0]=n;
        for(i=1; i<=x[0]; i++)
        {
            x[i]=s[n-i]-'0';
        }
    }
    // Supraincarcarea operatorilor aritmetici
    HUGE operator += (long long &a);
    long long operator % (long long k);
};
HUGE HUGE::operator += (long long &a)
{
    // x = x + other.x;
    int i, tr, aux;
    for(i=1, tr=0; i<=x[0]; i++)
    {
        aux = x[i] + a % 10 + tr;
        x[i] = aux % BASE;
        tr = aux / BASE;
        a/=10;
    }
    if(tr)
        x[++x[0]] = tr;
    return (*this);
}
long long HUGE::operator % (long long k)
{
    long long i, r=0;
    for (i=x[0]; i>=1; i--)
    {
        r = r * 10 + x[i];
        r = r % k;
    }
    return r;
}
int main()
{
    ios_base::sync_with_stdio(0);
    fin.tie(0);
    long long d, r, aux;
    fin >> s >> d;
    HUGE a(s);
    r = a % d;
    if(!r)
        a.print();
    else
    {
        aux = d - r;
        a += aux;
        a.print();
    }
    return 0;
}