// Original C++ solution (slower):
#include "bits/stdc++.h"

#pragma GCC optimize("Ofast")



// Begin {{{

using namespace std;



#ifndef DEBUG

#define dump(...)

#endif



template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }

template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }



template <class T>

inline vector<T> make_v(const T &initvalue, size_t sz) {

    return vector<T>(sz, initvalue);

}



template <class T, class... Args>

inline auto make_v(const T &initvalue, size_t sz, Args... args) {

    return vector<decltype(make_v<T>(initvalue, args...))>(sz, make_v<T>(initvalue, args...));

}



constexpr int INF = 0x3f3f3f3f;

constexpr int64_t LINF = 0x3f3f3f3f3f3f3f3fLL;

// }}} End



constexpr int dy[] = {0, 1, 0, -1, -1, 1, 1, -1};

constexpr int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};



inline bool inside(int y, int x, int H, int W) {

    return (y >= 0 && x >= 0 && y < H && x < W);

}



signed main() {

    ios_base::sync_with_stdio(false);

    cin.tie(nullptr);



    size_t N, K; cin >> N >> K;



    vector<bool> hate(10, false);

    for (size_t i = 0; i < K; ++i) {

        size_t d; cin >> d;

        hate[d] = true;

    }



    const auto ok = [&](size_t n) {

        string s = to_string(n);

        for (auto si: s) {

            if (hate[si - '0']) {

                return false;

            }

        }

        return true;

    };



    while (true) {

        if (ok(N)) {

            return cout << N << "\n", 0;

        }

        N++;

    }



    return 0;

}


// Optimized solution to the same problem (faster):
#include "bits/stdc++.h"



// Begin Header {{{

using namespace std;



#ifndef DEBUG

#define dump(...)

#endif



#define all(x) x.begin(), x.end()

#define rep(i, b, e) for (intmax_t i = (b), i##_limit = (e); i < i##_limit; ++i)

#define reps(i, b, e) for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)

#define repr(i, b, e) for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)

#define var(Type, ...) Type __VA_ARGS__; input(__VA_ARGS__)



constexpr size_t    operator""_zu(unsigned long long value) { return value; };

constexpr intmax_t  operator""_jd(unsigned long long value) { return value; };

constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };



constexpr int INF = 0x3f3f3f3f;

constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;



template <class T, class Compare = less<>>

using MaxHeap = priority_queue<T, vector<T>, Compare>;

template <class T, class Compare = greater<>>

using MinHeap = priority_queue<T, vector<T>, Compare>;



inline void input() {}

template <class Head, class... Tail>

inline void input(Head&& head, Tail&&... tail) {

    cin >> head;

    input(forward<Tail>(tail)...);

}



template <class T>

inline istream& operator>>(istream &is, vector<T> &vec) {

    for (auto &e: vec) {

        is >> e;

    }

    return is;

}



inline void output() { cout << "\n"; }

template <class Head, class... Tail>

inline void output(Head&& head, Tail&&... tail) {

    cout << head;

    if (sizeof...(tail)) {

        cout << " ";

    }

    output(forward<Tail>(tail)...);

}



template <class T>

inline ostream& operator<<(ostream &os, const vector<T> &vec) {

    static constexpr const char *delim[] = {" ", ""};

    for (const auto &e: vec) {

        os << e << delim[&e == &vec.back()];

    }

    return os;

}



template <class T>

inline vector<T> makeVector(const T &initValue, size_t sz) {

    return vector<T>(sz, initValue);

}



template <class T, class... Args>

inline auto makeVector(const T &initValue, size_t sz, Args... args) {

    return vector<decltype(makeVector<T>(initValue, args...))>(sz, makeVector<T>(initValue, args...));

}



template <class Func>

class FixPoint : Func {

public:

    explicit constexpr FixPoint(Func&& f) noexcept : Func(forward<Func>(f)) {}



    template <class... Args>

        constexpr decltype(auto) operator()(Args&&... args) const {

            return Func::operator()(*this, std::forward<Args>(args)...);

        }

};



template <class Func>

static inline constexpr decltype(auto) makeFixPoint(Func&& f) noexcept {

    return FixPoint<Func>{forward<Func>(f)};

}



template <class Container>

struct reverse_t {

    Container &c;

    reverse_t(Container &c) : c(c) {}

    auto begin() { return c.rbegin(); }

    auto end() { return c.rend(); }

};



template <class Container>

auto reversed(Container &c) {

    return reverse_t<Container>(c);

}



template <class T>

inline bool chmax(T &a, const T &b) noexcept {

    return b > a && (a = b, true);

}



template <class T>

inline bool chmin(T &a, const T &b) noexcept {

    return b < a && (a = b, true);

}



template <class T>

inline T diff(const T &a, const T &b) noexcept {

    return a < b ? b - a : a - b;

}

// End Header }}}



signed main() {

    ios_base::sync_with_stdio(false);

    cin.tie(nullptr);

    cout.setf(ios_base::fixed);

    cout.precision(10);

    var(size_t, N, K);

    vector<size_t> dislike(10);

    rep(i, 0, K) {

        var(size_t, d);

        dislike[d] = true;

    }

    vector<size_t> like;

    rep(i, 0, 10) if (!dislike[i]) like.emplace_back(i);

    const auto res = makeFixPoint([&](auto rec, intmax_t cur) -> intmax_t {

        if (cur >= N) return cur;

        intmax_t ret = LINF;

        for (const auto nxt: like) {

            if (cur + nxt == 0) continue;

            chmin(ret, rec(cur * 10 + nxt));

        }

        return ret;

    })(0);

    output(res);

    return 0;

}


// Fastest known solution for this problem: