#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int N, K;
    cin >> N >> K;
    vector<int> D;
    vector<int> AU;
    int au=0;
    for(int k=0; k<K; k++) {
        int d;
        cin >> d;
        D.push_back(d);
        // cout << d << endl;
        while(d!=au && au<10) {
            // cout << au << endl;
            AU.push_back(au);
            au++;
        }
        au++;
    }

    while(au<10) {
        AU.push_back(au);
        au++;
    }
    
    // for(int i=0; i<AU.size(); i++) {
    //     cout << AU[i] << endl;
    // }

    int cur_10=10000;
    int ind=5;
    while(N/cur_10==0) {
        cur_10/=10;
        ind--;
    }
    // cout << ind << endl;
    int re_10=cur_10;
    int max_ind=ind;
    vector<bool> m_o_l(max_ind, true);
    
    bool flag=true;
    int tmpN=N;
    while(tmpN!=0 || flag) {
        // cout << tmpN/cur_10 << endl;
        if(upper_bound(AU.begin(), AU.end(), tmpN/cur_10)==AU.end()) {
            m_o_l[max_ind-ind]=false;
        }
        if(lower_bound(AU.begin(), AU.end(), tmpN/cur_10)==AU.end()) {
            // cout << lower_bound(AU.begin(), AU.end(), tmpN/cur_10)-AU.begin() << endl;
            flag=false;
            break;
        }
        tmpN %= cur_10;
        ind--;
        cur_10 /= 10;
        if(cur_10==0) {
            flag=false;
        }
        // cout << tmpN << ", " << cur_10 << endl;
    }

    // cout << ind << endl;


    int ans=0;
    flag = true;
    bool min_flag=false;
    if(ind==0) {
        while(N!=0 || flag) {
            if(min_flag) {
                ans += re_10*AU[0];
            } else {
                ans += re_10*(*lower_bound(AU.begin(), AU.end(), N/re_10));
                if(*lower_bound(AU.begin(), AU.end(), N/re_10)!=N/re_10) {
                    min_flag = true;
                }
            }
            
            
            N %= re_10;
            re_10 /= 10;
            if(re_10==0) {
                flag=false;
            }
        }
    } else {
        bool add_d=true;
        int m_ind;
        if(max_ind==ind) {
            add_d = true;
        } else {
            for(int i=max_ind-ind; i>=0; i--) {
                if(m_o_l[i]) {
                    add_d = false;
                    m_ind = i;
                    break;
                }
            }
        }
        
        if(add_d) {
            int tmp_ind=max_ind;
            while(tmp_ind!=-1) {
                ans *= 10;
                if(tmp_ind==max_ind) {
                    if(AU[0]!=0) {
                        ans += AU[0];
                    } else {
                        ans += AU[1];
                    }
                } else {
                    ans += AU[0];
                }
                tmp_ind--;
            }
        } else {
            int tmp_ind=max_ind;
            // cout << N << ", " << re_10 << endl;
            // cout << m_ind << ", " << tmp_ind << endl;
            while(tmp_ind!=0) {
                // cout << ans << endl;
                if(tmp_ind!=(max_ind-m_ind)) {
                    ans += re_10*AU[0];
                } else {
                    ans += re_10*(*(lower_bound(AU.begin(), AU.end(), N/re_10)+1));
                }
                N %= re_10;
                re_10 /= 10;
                tmp_ind--;
            }
        }
    }
    
    cout << ans << endl;


    return 0;
    
}

Measured memory_bytes: 256