#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;

const int MaxDigits = 1000000;
const int BASE = 10;
const int MaxInt = (1LL << 31) - 1;
char s[MaxDigits + 5];

class HugeN{

    private: int x[MaxDigits + 5];

    public:
        HugeN(){
            x[0] = 1;
            memset(x, 0, sizeof(x));
        }

        HugeN(int n){
            memset(x, 0, sizeof(x));

            do{
                x[++x[0]] = n % 10;
                n /= 10;
            }while(n);
        }

        HugeN(long long n){
            memset(x, 0, sizeof(x));

            do{
                x[++x[0]] = n % 10;
                n /= 10;
            }while(n);
        }

        HugeN(HugeN &other){
            memset(x, 0, sizeof(x));
            memcpy(x, other.x, sizeof(other.x));
        }

        HugeN(char *s){
            x[0] = strlen(s);
            for(int i = 1; i <= x[0]; ++i)
                x[i]= s[x[0] - i] - '0';
        }

        void print(){
            for(int i = x[0]; i >= 1; --i)
                printf("%d", x[i]);
        }

        int cmp(const HugeN &other);
        HugeN operator + (const HugeN &other);
        HugeN operator + (int k);
        HugeN operator + (long long k);
        HugeN operator - (const HugeN &other);
        HugeN operator - (int k);
        HugeN operator * (const HugeN &other);
        HugeN operator * (int k);
        HugeN operator / (const HugeN &other);
        HugeN operator / (int k);
        HugeN operator % (const HugeN &other);
        int operator % (int k);
        long long operator % (long long k);
        HugeN operator ^ (int k);
        HugeN operator += (const HugeN &other);
        HugeN operator -= (const HugeN &other);
        HugeN operator *= (const HugeN &other);
        HugeN operator *= (int k);
        HugeN operator /= (int k);
        bool operator > (const HugeN &other);
        bool operator >= (const HugeN &other);
        bool operator < (const HugeN &other);
        bool operator <= (const HugeN &other);
        bool operator == (const HugeN &other);
        bool operator != (const HugeN &other);
};

int HugeN::cmp(const HugeN &other){

    if(x[0] > other.x[0])
        return 1;
    if(x[0] < other.x[0])
        return -1;

    for(int i = x[0]; i >= 1; --i)
        if(x[i] > other.x[i])
            return 1;
        else if(x[i] < other.x[i])
            return -1;
    return 0;
}

HugeN HugeN::operator + (const HugeN &other)
{
    HugeN temp;
    temp.x[0] = max(x[0], other.x[0]);
    int tr = 0, aux;

    for(int i = 1; i <= temp.x[0]; ++i){
        aux = x[i] + other.x[i] + tr;
        temp.x[i] = aux % BASE;
        tr = aux / BASE;
    }

    if(tr > 0)
        temp.x[++x[0]] = tr;
    return temp;
}

HugeN HugeN::operator + (long long k)
{
    int nr = 0;
    while(k){
        x[++nr] += k % 10;
        k /= 10;
    }

    for(int i = 1; i <= x[0]; ++i){
        if(x[i] > 9)
            x[i + 1]++, x[i] %= 10;
    }

    if(x[x[0] + 1] != 0)
        x[0]++;

    return (*this);
}

long long HugeN::operator % (long long k)
{
    long long r = 0;
    for(int i  = x[0]; i >= 1; --i){
        r = (r * 10 + x[i]) % k;
    }

    return r;
}

int main()
{
    freopen("next.in","r",stdin);
    freopen("next.out","w",stdout);

    gets(s); HugeN x(s);
    long long k; cin >> k;


    long long r = x % k;
    k -= r;
    x = x + k;

    x.print();
    return 0;
}