#include <iostream>
#include <map>
#include <vector>
#include <deque>
#include <array>
#include <set>
#include <sstream>


std::deque<int> poles; // constamment de taille l !
std::multiset<int> set;
int counter { 0 };

// O(1)
bool can_reach(int pos, int target)
{
    // hors-limites
    if (target < 0 || target >= poles.size()) return false;
    // taille des bordures du sous-élément différentes, c'est donc impossible
    if (poles[pos] != poles[target]) return false;

    return *set.rbegin() <= poles[pos]; // si l'élément maximal du set (get en O(1) via rbegin()) est supérieur à la taille on retourne false
}

// O(1)
void process(int pos, int length)
{
    if (can_reach(pos, pos + length))
    {
        ++counter;
    }
}

// O(log n)
void erase(std::multiset<int>& set, int val)
{
    auto itr = set.find(val);
    if(itr!=set.end())
    {
        set.erase(itr);
    }
}

// The Algo :
// On ne travaille que sur des sous ensembles de taille l
// en gros, pour ne pas exploser la limite de mémoire, on utilise comme un genre de fenêtre glissante, qui récupère progressivement des données de l'entrée standard
// à côté, on a un multiset, qui nous permet d'ajouter des valeurs en O(log n), et de récupérer le maximum en O(1) :
// pour chaque sous-ensemble, on vérifier que le maximum du sous ensemble est <= les valeurs d'extrémités du sous ensemble
// a chaque fois que oui, on augmente le compteur
// et on l'affiche

int main()
{
    int length, amt_poles;
    std::cin >> length >> amt_poles;

    // O(n log n)
    for (int i { 0 }; i < amt_poles; ++i)
    {
        int val;
        std::cin >> val;

        // O(log n)
        // on construit encore le sous-ensemble initial
        if (poles.size() <= length)
        {
            set.emplace(val);          poles.push_back(val);
        }
        // O(2*log n)
        // on fait une rotation du sous-ensemble de taille l avec un nouvel élément récupéré de stdin
        else
        {
            process(0, length);

            erase(set, poles.front()); poles.pop_front();
            set.emplace(val);          poles.push_back(val);
        }
    }
    process(0, length);

    std::cout << counter;
}