# include <vector>

# include <stdio.h>

# include <string.h>

# include <iostream>

# include <algorithm>

// # include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef long double ld;

typedef unsigned long long ull;

const int M = 2e5 + , N = 4e5 + ;

const int mod = 1e9+;

# define RG register

# define ST static

# define lb(x) (x&(-x))

struct BIT {

    int c[N], n;

    inline void set(int _n) {

        memset(c, , sizeof c);

        n = _n;

    }

    inline void edt(int x, int d) {

        for (; x<=n; x+=lb(x)) c[x] += d;

    }

    inline int sum(int x) {

        int ret = ;

        for (; x; x-=lb(x)) ret += c[x];

        return ret;

    }

    inline int sum(int x, int y) {

        if(x>y) return ;

        return sum(y) - sum(x-);

    }

}T;

int n;

vector<int> ps;

struct pa {

    int x, pos;

    pa() {}

    pa(int x, int pos) : x(x), pos(pos) {}

    friend bool operator < (pa a, pa b) {

        return a.x > b.x;

    }

}p[M];

int L[M], R[M];

int main() {

    cin >> n;

    T.set(n);

    for (int i=; i<=n; ++i) {

        scanf("%d", &p[i].x);

        p[i].pos = i;

        ps.push_back(p[i].x);

    }

    sort(ps.begin(), ps.end());

    ps.erase(unique(ps.begin(), ps.end()), ps.end());

    for (int i=; i<=n; ++i) p[i].x = lower_bound(ps.begin(), ps.end(), p[i].x) - ps.begin() + ;

    sort(p+, p+n+);

    for (int i=; i<=n; ++i) {

        int j = i;

        while(j<n && p[j+].x == p[i].x) ++j;

        for (int k=i; k<=j; ++k) {

            L[k] = T.sum(, p[k].pos-);

            R[k] = T.sum(p[k].pos+, n);

        }

        for (int k=i; k<=j; ++k) T.edt(p[k].pos, );

        i = j;

    }

    int ans = ;

    for (int i=; i<=n; ++i)

        if(max(R[i], L[i]) > *min(R[i], L[i]))

            ++ans;

    cout << ans << endl;

    return ;

}