#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
//---------------------------------------------------------------------------------------------------
template<class T> struct PriorityQueue {
    vector<T> d;

    PriorityQueue() {}

    PriorityQueue(const vector<T> &d_) : d(d_) {
        make_heap();
    }

    template<class Iter> PriorityQueue(Iter first, Iter last) : d(first, last) {
        make_heap();
    }

    void push(const T &x) {
        int k = d.size();
        d.push_back(x);
        up(k);
    }

    void pop_min() {
        if (d.size() < 3u) {
            d.pop_back();
        }
        else {
            swap(d[1], d.back()); d.pop_back();
            int k = down(1);
            up(k);
        }
    }

    void pop_max() {
        if (d.size() < 2u) {
            d.pop_back();
        }
        else {
            swap(d[0], d.back()); d.pop_back();
            int k = down(0);
            up(k);
        }
    }

    const T& get_min() const {
        return d.size() < 2u ? d[0] : d[1];
    }

    const T& get_max() const {
        return d[0];
    }

    int size() const { return d.size(); }

    bool empty() const { return d.empty(); }

    void make_heap() {
        for (int i = d.size(); i--; ) {
            if (i & 1 && d[i - 1] < d[i]) swap(d[i - 1], d[i]);
            int k = down(i);
            up(k, i);
        }
    }

    inline int parent(int k) const {
        return ((k >> 1) - 1)&~1;
    }

    int down(int k) {
        int n = d.size();
        if (k & 1) { // min heap
            while (2 * k + 1 < n) {
                int c = 2 * k + 3;
                if (n <= c || d[c - 2] < d[c]) c -= 2;
                if (c < n && d[c] < d[k]) { swap(d[k], d[c]); k = c; }
                else break;
            }
        }
        else { // max heap
            while (2 * k + 2 < n) {
                int c = 2 * k + 4;
                if (n <= c || d[c] < d[c - 2]) c -= 2;
                if (c < n && d[k] < d[c]) { swap(d[k], d[c]); k = c; }
                else break;
            }
        }
        return k;
    }

    int up(int k, int root = 1) {
        if ((k | 1) < (int)d.size() && d[k&~1] < d[k | 1]) {
            swap(d[k&~1], d[k | 1]);
            k ^= 1;
        }

        int p;
        while (root < k && d[p = parent(k)] < d[k]) { // max heap
            swap(d[p], d[k]);
            k = p;
        }
        while (root < k && d[k] < d[p = parent(k) | 1]) { // min heap
            swap(d[p], d[k]);
            k = p;
        }
        return k;
    }
};
/*---------------------------------------------------------------------------------------------------
　　　　　　　　　　　 ∧＿∧  
　　　　　 ∧＿∧ 　（´<_｀ ）　 Welcome to My Coding Space!
　　　　 （ ´_ゝ`）　/　 ⌒i     
　　　　／　　　＼　 　  |　|     
　　　 /　　 /￣￣￣￣/　　|  
　 ＿_(__ﾆつ/　    ＿/ .| .|＿＿＿＿  
　 　　　＼/＿＿＿＿/　（u　⊃  
---------------------------------------------------------------------------------------------------*/
 
 
 
int N, M;
vector<pair<int, int>> v;
//---------------------------------------------------------------------------------------------------
int get() {
    int d; cin >> d;
    string s; cin >> s;
    int h = (s[0] - '0') * 10 + s[1] - '0';
    int m = (s[3] - '0') * 10 + s[4] - '0';
    return d * 24 * 60 + h * 60 + m;
}
//---------------------------------------------------------------------------------------------------
void _main() {
    cin >> N >> M;
    rep(i, 0, M) {
        int s = get(), t = get();
        v.push_back({ s, t });
    }
    sort(v.begin(), v.end());

    PriorityQueue<int> que;

    int ans = 0;
    fore(p, v) {
        int s = p.first;
        int t = p.second;

        while (!que.empty() && que.get_min() < s) que.pop_min();
        if (que.size() == N) {
            if (t < que.get_max()) {
                que.pop_max();
                que.push(t);
            }
            continue;
        }

        que.push(t);
        ans++;
    }
    cout << ans << endl;
}