#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;

namespace{
typedef long long LL;

template <class Tp>
struct fenwick_tree{
	typedef unsigned size_type;
	std::vector<Tp> bit;
	int minidx;

	fenwick_tree(){}
	explicit fenwick_tree(size_type n, int minidx_ = 1){
		init(n, minidx_);
	}
	void init(size_type n, int minidx_ = 1){
		bit.assign(n + 1, Tp());
		minidx = minidx_;
	}
	Tp sum(int i_) const{
		if(i_ < minidx){ return Tp(); }
		size_type i = i_ - minidx + 1;
		Tp s = Tp();
		while(i){
			s += bit[i];
			i -= i & -i;
		}
		return s;
	}
	void add(int i_, Tp x){
		if(i_ < minidx){ return; }
		size_type i = i_ - minidx + 1;
		size_type sz = bit.size();
		while(i < sz){
			bit[i] += x;
			i += i & -i;
		}
	}
};

void main2(){
	int n;
	scanf("%d", &n);
	vector<int> as(n);
	for(int i = 0; i < n; ++i){
		scanf("%d", &as[i]);
	}
	int mval = *max_element(as.begin(), as.end());
	vector<vector<int> > postbl(mval + 1);
	for(int i = 0; i < n; ++i){
		postbl[as[i]].push_back(i);
	}

	fenwick_tree<int> ft;
	vector<int> hs;
	hs.reserve(n + 1);
	LL ans = 0;
	for(int x = 0; x <= mval; ++x){
		const vector<int> &poss = postbl[x];
		int sz = poss.size();
		for(int l = 0; l < sz; ){
			int r;
			for(r = l + 1; r < sz && poss[r] - poss[r - 1] <= sz; ++r);
			int beg = max(poss[l] - sz + 1, 0);
			int en = min(poss[r - 1] + sz, n);
			hs.assign(1, 0);
			for(int i = beg; i < en; ++i){
				hs.push_back(hs.back() + (x == as[i] ? 1 : -1));
			}
			int minh = *min_element(hs.begin(), hs.end());
			int maxh = *max_element(hs.begin(), hs.end());
			ft.init(maxh - minh + 2, minh);
			for(int y : hs){
				ans += ft.sum(y - 1);
				ft.add(y, 1);
			}
			l = r;
		}
	}
	printf("%lld\n", ans);
}

}

int main(){ main2(); }