#include <bits/stdc++.h>

#define rep(i, n) for(int i = 0 ; i < (int)(n) ; i++)
typedef long long ll;
typedef long double Double;

namespace stream {
    template<class T>
    class Stream {
        std::vector<T> instance;
    public:

        Stream(const std::vector<T> &instance) : instance(instance) {}


        template<class F>
        Stream<T> filter(const F &func) {
            return filterPrivate([&](T &t, int &idx) { return func(t); });
        }

        template<class F>
        Stream<T> filterWithIndex(const F &func) {
            return filterPrivate(func);
        }

        template<class F>
        auto map(const F &func) {
            return mapPrivate([&](T &t, int &idx) { return func(t); });
        }

        template<class F>
        auto mapWithIndex(const F &func) {
            return mapPrivate(func);
        }

        template<class F, class R>
        R reduce(const F &func, const R &init_value) {
            R ans = init_value;
            for (int i = 0; i < instance.size(); i++) {
                ans = func(ans, instance[i]);
            }
            return ans;
        }

        template<class F>
        Stream<T> sort(F cmp) {
            std::vector<T> v = instance;
            std::sort(v.begin(), v.end(), cmp);
            return Stream<T>(v);
        }

        Stream<T> sort() {
            std::vector<T> v = instance;
            std::sort(v.begin(), v.end());
            return Stream<T>(v);
        }

        Stream<T> sort_reversed() {
            std::vector<T> v = instance;
            std::sort(v.rbegin(), v.rend());
            return Stream<T>(v);
        }

        Stream<T> unique() {
            std::unordered_set<T> existing;
            std::vector<T> ans;
            for (auto &&i : instance) {
                if (existing.count(i)) { continue; }
                existing.insert(i);
                ans.push_back(i);
            }
            return Stream<T>(ans);
        }

        unsigned long count() {
            return instance.size();
        }

        T sum() {
            return std::accumulate(instance.begin(), instance.end(), T());
        }

        std::vector<T> collect() {
            return instance;
        }

        std::set<T> toSet() {
            return std::set<T>(instance.begin(), instance.end());
        }

    private:
        template<class F>
        Stream<T> filterPrivate(F func) {
            std::vector<T> ans;

            for (int i = 0; i < instance.size(); i++) {
                if (func(instance[i], i)) {
                    ans.push_back(instance[i]);
                }
            }
            return Stream<T>(ans);
        }

        template<class F>
        auto mapPrivate(F func) {
            using R = typename std::result_of<F(T, int)>::type;
            std::vector<R> ans;
            for (int i = 0; i < instance.size(); i++) {
                ans.push_back(func(instance[i], i));
            }
            return Stream<R>(ans);
        }

    };

    template<class T>
    Stream<T> _(const std::vector<T> &instance) {
        return Stream<T>(instance);
    };

    template<class T>
    Stream<T> _(const std::set<T> &instance) {
        return Stream<T>(std::vector<T>(instance.begin(), instance.end()));
    };

    template<class T, class U>
    Stream<std::pair<T, U>> _(const std::vector<T> &a, std::vector<U> &b) {
        const unsigned long &size = std::min(a.size(), b.size());
        std::vector<std::pair<T, U>> zipped;
        return _(zipped);
    }

    Stream<int> range(int a, int b) {
        if (a >= b) return Stream<int>(std::vector<int>());
        std::vector<int> ans(b - a);
        for (int i = 0; i < b - a; i++)
            ans[i] = a + i;
        return Stream<int>(ans);
    }

    Stream<int> range(int n) {
        return range(0, n);
    }
}

namespace input {
    template<class T>
    void read(std::vector<T> &v) {
        for (int i = 0; i < v.size(); i++) std::cin >> v[i];
    }

    std::vector<int> readIntArray(int n) {
        std::vector<int> a(n);
        read(a);
        return a;
    }

    long long readLong() {
        long long x;
        std::cin >> x;
        return x;
    }

    int readInt() {
        long long x = readLong();
        assert(x >= INT_MIN && x <= INT_MAX);
        return (int) x;
    }

    std::string readWord() {
        std::string x;
        std::cin >> x;
    }
};

using namespace std;
using namespace stream;
using namespace input;

int main() {
    int N = readInt();
    int M = readInt();
    set<int> A = _(readIntArray(M)).toSet();
    cout << range(M).filter([&](int i) {
        return !A.count(i + 1);
    }).count() << endl;
}



Measured memory_bytes: 3172