#include <cstdio>
#include <cstring>
#include <vector>
using namespace std ;

class Huge : protected vector<int>{

private:

    static const int SIZE = 500002;
    static const int BASE = 100;
    static const int EXP = 2;

public:

    inline Huge();
    inline Huge(long long N);
    inline Huge(char N[]);

    inline void print();

    inline int  compare(Huge &B);
    inline bool operator <  (Huge &B);
    inline bool operator <= (Huge &B);
    inline bool operator == (Huge &B);
    inline bool operator >  (Huge &B);
    inline bool operator >= (Huge &B);
    inline bool operator != (Huge &B);
    inline int  null();

    inline Huge operator +  (Huge &B);
    inline void operator += (Huge &B);

    inline Huge operator *  (int B);
    inline void operator *= (int B);
    inline Huge operator *  (Huge &B);
    inline void operator *= (Huge &B);

    inline Huge operator -  (Huge &B);
    inline void operator -= (Huge &B);

    inline Huge operator /  (int B);
    inline void operator /= (long long B);

    inline int  operator %  (long long B);
    inline void operator %= (int B);

    inline Huge operator ^  (Huge B);

    inline void operator ++ (int);
    inline void operator ++ ();
    inline void operator -- (int);
    inline void operator -- ();

    inline Huge sqrt();

    inline Huge toBinary();
    inline Huge toDecimal();

};

#define A (*this)

inline Huge :: Huge(){
    A.resize(SIZE);
}

inline Huge :: Huge(long long N){

    A.resize(SIZE);

    for(A[0] = 0; N > 0; N /= BASE){
        A[++A[0]] = N % BASE;
    }
}

inline Huge :: Huge(char N[]){

    A.resize(SIZE); A[0] = 0;

    for(int length = strlen(N); length > 0; length -= EXP){

        A[0]++;

        for(int i = max(0, length - EXP); i < length; i++){
            A[A[0]] = A[A[0]] * 10 + N[i] - '0';
        }
    }
}

inline void Huge :: print(){

    printf("%d", A[A[0]]);

    for(int i = A[0] - 1; i > 0; i--){
        printf("%02d", A[i]); // %0EXPd
    }printf("\n");
}

inline int Huge :: compare(Huge &B){

    for(; A[0] && !A[A[0]]; A[0]--);
    for(; B[0] && !B[B[0]]; B[0]--);

    if(A[0] != B[0]) return (A[0] < B[0]) ? -1 : 1;

    for(int i = A[0]; i > 0; i--)
        if(A[i] != B[i]) return (A[i] < B[i]) ? -1 : 1;

    return 0;
}

inline bool Huge :: operator < (Huge &B){
    return A.compare(B) == -1;
}

inline bool Huge :: operator <= (Huge &B){
    return A.compare(B) != 1;
}

inline bool Huge :: operator == (Huge &B){
    return A.compare(B) == 0;
}

inline bool Huge :: operator > (Huge &B){
    return A.compare(B) == 1;
}

inline bool Huge :: operator >= (Huge &B){
    return A.compare(B) != -1;
}

inline bool Huge :: operator != (Huge &B){
    return A.compare(B) != 0;
}

inline int Huge :: null(){
    return A[0] == 0 || (A[0] == 1 && A[1] == 0);
}

inline Huge Huge :: operator + (Huge &B){

    Huge C; int i, carry = 0;

    for(i = 1; i <= A[0] || i <= B[0] || carry; i++, carry /= BASE)
        C[i] = (carry += ((i <= A[0]) ? A[i] : 0) + ((i <= B[0]) ? B[i] : 0)) % BASE;
    C[0] = i - 1;

    return C;
}

inline void Huge :: operator += (Huge &B){

    int i, carry = 0;

    for(i = 1; i <= A[0] || i <= B[0] || carry; i++, carry /= BASE)
        A[i] = (carry += ((i <= A[0]) ? A[i] : 0) + ((i <= B[0]) ? B[i] : 0)) % BASE;
    A[0] = i - 1;
}

inline Huge Huge :: operator * (int B){

    Huge C; int i; long long carry = 0;

    for(i = 1; i <= A[0] || carry; i++, carry /= BASE)
        C[i] = (carry += 1LL * ((i <= A[0]) ? A[i] : 0) * B) % BASE;
    C[0] = i - 1;

    return C;
}

inline void Huge :: operator *= (int B){

    int i; long long carry = 0;

    for(i = 1; i <= A[0] || carry; i++, carry /= BASE)
        A[i] = (carry += 1LL * ((i <= A[0]) ? A[i] : 0) * B) % BASE;
    A[0] = i - 1;
}

inline Huge Huge :: operator * (Huge &B){

    Huge C; int i, j; long long carry;

    for(i = 1; i <= A[0]; i++){
        for(carry = 0, j = 1; j <= B[0] || carry; j++, carry /= BASE)
            C[i + j - 1] = (carry += C[i + j - 1] + (1LL * ((i <= A[0]) ? A[i] : 0) * ((j <= B[0]) ? B[j] : 0))) % BASE;
        if(i + j - 2 > C[0]) C[0] = i + j - 2;
    }return C;
}

inline void Huge :: operator *= (Huge &B){

    Huge C; int i, j; long long carry;

    for(i = 1; i <= A[0]; i++){
        for(carry = 0, j = 1; j <= B[0] || carry; j++, carry /= BASE)
            C[i + j - 1] = (carry += C[i + j - 1] + (1LL * ((i <= A[0]) ? A[i] : 0) * ((j <= B[0]) ? B[j] : 0))) % BASE;
        if(i + j - 2 > C[0]) C[0] = i + j - 2;
    }A = C;
}

inline Huge Huge :: operator - (Huge &B){

    Huge C = A; int i, carry = 0;

    for(i = 1; i <= C[0]; i++){
        C[i] -= ((i <= B[0]) ? B[i] : 0) + carry;
        C[i] += (carry = C[i] < 0) * BASE;
    }
    for(; C[0] > 1 && !C[C[0]]; C[0]--);

    return C;
}

inline void Huge :: operator -= (Huge &B){

    int i, carry = 0;

    for(i = 1; i <= A[0]; i++){
        A[i] -= ((i <= B[0]) ? B[i] : 0) + carry;
        A[i] += (carry = A[i] < 0) * BASE;
    }
    for(; A[0] > 1 && !A[A[0]]; A[0]--);
}

inline Huge Huge :: operator / (int B){

    Huge C = A; int i; long long carry = 0;

    for(i = C[0]; i > 0; i--, carry %= B)
        C[i] = (carry = carry * BASE + C[i]) / B;

    for(; C[0] > 1 && !C[C[0]]; C[0]--);

    return C;
}

inline void Huge :: operator /= (long long B){

    int i; long long carry = 0;

    for(i = A[0]; i > 0; i--, carry %= B)
        A[i] = (carry = carry * BASE + A[i]) / B;

    for(; A[0] > 1 && !A[A[0]]; A[0]--);
}

inline int Huge :: operator % (long long B){

    int i, carry = 0;

    for(i = A[0]; i > 0; i--)
        carry = (1LL * carry * BASE + A[i]) % B;

    return carry;
}

inline void Huge :: operator %= (int B){

    int i, carry = 0;

    for(i = A[0]; i > 0; i--)
        carry = (1LL * carry * BASE + A[i]) % B;

    A = carry;
}

inline Huge Huge :: operator ^ (Huge B){

    Huge result = 1, C = A;

    while(!B.null()){
        if(B[1] & 1) result *= C;
        B /= 2;
        C *= C;
    }
    return result;
}

inline void Huge :: operator ++ (int){
    Huge B = 1; A += B;
}

inline void Huge :: operator ++ (){
    A++;
}

inline void Huge :: operator -- (int){
    Huge B = 1; A -= B;
}

inline void Huge :: operator -- (){
    A--;
}

inline Huge Huge :: sqrt(){

    Huge power, guess, B;

    for(power = 1; power < A; power *= 2);

    for(B[0] = 1; !power.null(); power /= 2){
        guess = power; guess += B; guess *= guess;
        if(guess <= A) B += power;
    }
    return B;
}

inline Huge Huge :: toBinary(){

    Huge B = A, C;

    for(; !B.null(); C[++C[0]] = B[1] & 1, B /= 2);

    return C;
}

inline Huge Huge :: toDecimal(){

    Huge B = 1, C;

    for(int i = 1; i <= A[0]; ++i, B *= 2){
        if(A[i] == 1) C += B ;
    }
    return C;
}

#undef A

char numberN[1000002];
long long D;
Huge N;

int main(){

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

    scanf("%s", numberN);
    scanf("%lld", &D);

    N = numberN;

    if(N % D == 0){
        printf("%s", numberN);
        return 0;
    }

    N /= D; N++; N *= D;

    N.print();

return 0;
}