# define _CRL_SECURE_NO_WARNINGS

# include <iostream>
# include <string>
# include <iomanip>
# include <stdio.h>
# include <array>
# include <numeric>
# include <algorithm>
# include <vector>
# include <functional>
# include <fstream>
# include <random>
# include <bitset>
# include <sstream>
# include <set>




using Ull = unsigned long long;
using Ll = long long;

template<typename T>
using Vec = std::vector<T>;

template<typename T, size_t L>
using Ary = std::array<T, L>;

namespace
{


    template<typename T>
    std::istream& operator >> (std::istream& is, std::vector<T>& vec)
    {
        for (T& x : vec) is >> x;
        return is;
    }
    template<typename T, size_t L>
    std::istream& operator >> (std::istream& is, std::array<T, L>& ary)
    {
        for (T& x : ary) is >> x;
        return is;
    }

    template<typename T, size_t L>
    std::istream& operator >> (std::istream& is, T(&ary)[L])
    {
        for (int i{}; i < L; ++i) is >> ary[i];
        return is;
    }

    template<typename T>
    std::ostream& operator << (std::ostream& os, const std::vector<T>& vec)
    {
        for (const T& x : vec) os << x << " ";
        return os;
    }

    template<typename T>
    std::ostream& operator << (std::ostream& os, const std::vector<std::vector<T>>& vec)
    {
        for (const std::vector<T>& x : vec) os << x << "\n";
        return os;
    }

    namespace charAry
    {
        template<size_t L>
        std::istream& in(std::istream& is, char(&ary)[L])
        {
            return in(is, ary, L);
        }

        std::istream& in(std::istream& is, char* ary, size_t size)
        {
            for (int i{}; i < size; ++i)
            {
                char temp;
                is >> temp;
                ary[i] = temp;
            }
            return is;
        }
    }

    template<typename T>
    std::string to_string(std::vector<T> vec, std::string sep = " ")
    {
        using std::to_string;

        std::string result;
        for (T& x : vec) result += to_string(x) + sep;
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }
    template<>
    std::string to_string(std::vector<char> vec, std::string sep)
    {
        using std::to_string;

        std::string result;
        for (char c : vec) result += std::string{ c } +sep;
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L>
    std::string to_string(T(&ary)[L], std::string sep = " ", size_t size = L)
    {
        using std::to_string;

        std::string result;
        for (int i = 0; i < size; ++i) result += to_string(ary[i]);
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }
    template<size_t L>
    std::string to_string(char(&ary)[L], std::string sep = " ", size_t size = L)
    {
        using std::to_string;

        std::string result;
        for (int i = 0; i < size; ++i) result += ary[i];
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L, typename Function>
    void for_each(T(&ary)[L], Function lambda)
    {
        for (size_t i{}; i < L; ++i)
            lambda(static_cast<T&>(ary[i]));
    }

    template<typename T>
    void SetAll(T& container, typename T::value_type value = typename T::value_type{})
    {
        for (typename T::reference content : container)
            content = value;
    }

    template<typename T, size_t L>
    void SetAll(T(&ary)[L], T value = T{})
    {
        for (size_t i{}; i < L; ++i)
            ary[i] = value;
    }

    template<typename T, size_t L>
    std::array<T, L> AsContainer(T(&ary)[L], bool isSwap = true)
    {
        std::array<T, L> result;

        if (isSwap)
        {
            for (size_t i{}; i < L; ++i)
                std::swap(result[i], ary[i]);
        }
        else
        {
            for (size_t i{}; i < L; ++i)
                result[i] = ary[i];
        }

        return result;
    }

    template<size_t length>
    constexpr std::array<size_t, length> range()
    {
        std::array<size_t, length> range{};

        for (size_t i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T length)
    {
        std::vector<T> range(length);

        for (T i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T start, const T end)
    {
        if (start >= end) return std::vector<T>{};

        std::vector<T> range(end - start);

        for (T i{ start }; i < end; ++i)
            range[i - start] = i;

        return range;
    }

    bool IsPrime(const Ull n)
    {
        switch (n)
        {
        case 0: case 1:
            return false;
        case 2:
            return true;
        default:

            if (n % 2 == 0) return false;

            for (Ull i{ 3 }; i * i <= n; i += 2)
            {
                if (n % i == 0) return false;
            }
        }

        return true;
    }

    // 最大公約数
    int EuclideanAlg(int n1, int n2)
    {
        if (n1 < 0 || n2 < 0) return 0;
        if (n2 > n1) std::swap(n1, n2);

        int r;
        while ((r = n1 % n2) != 0)
        {
            n1 = n2;
            n2 = r;
        }

        return n2;
    }

    // 最小公倍数
    Ull LCM(const std::vector<Ull>& values)
    {
        if (values.size() == 0)
            return 0;
        if (values.size() == 1)
            return values[0];
        if (values.size() == 2)
            return values[0] * values[1] / static_cast<Ull>(EuclideanAlg(values[0], values[1]));

        auto mid = values.cbegin() + values.size() / 2;

        return LCM(std::vector<Ull>{LCM(std::vector<Ull>(values.begin(), mid)), LCM(std::vector<Ull>(mid, values.end()))});
    }


    void Solve();
}

# if true
int main()
{
    Solve();
    return 0;
}
# endif


namespace
{

    std::istream& operator >> (std::istream& in, std::pair<int, int>& pair)
    {
        in >> pair.first >> pair.second;
        return in;
    }

    void Solve()
    {
        using namespace std;

        int n; cin >> n;
        int m; cin >> m;
        Vec<pair<int, int>> data(m); cin >> data;

        std::sort(data.begin(), data.end());

        Vec<pair<int, int>> result;
        for (auto& val : data)
        {
            if (std::find_if(result.begin(), result.end(), [&](auto& range) {
                auto temp = std::pair<int, int>{
                    std::max(val.first, range.first),
                    std::min(val.second, range.second)
                };

                if (temp.first >= temp.second)
                {
                    return false;
                }

                if (val.first <= temp.first && temp.second <= val.second)
                {
                    range = temp;
                    return true;
                }

                return temp.first <= val.first && val.second <= temp.second;
            }) == result.end())
            {
                result.push_back(val);
            }
        }


        std::cout << result.size();

    }

}

Measured memory_bytes: 1024