#ifndef MAIN
#define MAIN
#include __FILE__

void solve() {
    int N;
    cin >> N;
    vector<ll> A(N);
    cin >> A;

    ll ans = 0, c = 0;
    rep(i, N - 1) {
        if (A[i] == A[i + 1])
            c = 0;
        else if (A[i] > A[i + 1])
            ans += c;
        else
            c++;
    }
    cout << ans << endl;
}

void _main() { solve(); }
#else

#ifdef DEBUG

#pragma GCC optimize("O0")

#else

#ifdef ONLINE_JUDGE

#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("trivial-auto-var-init=uninitialized")

#endif

#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("trivial-auto-var-init=uninitialized")

#endif

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

#include <atcoder/all>

#endif

using namespace std;
using namespace atcoder;

const char en = '\n';

using ll = long long;
using ld = long double;
using bl = bool;
using mint = modint998244353;
// using mint = modint1000000007;
//    using mint = modint;

istream& operator>>(istream& is, mint& m) {
    int val;
    is >> val;
    m = val;
    return is;
}

ostream& operator<<(ostream& os, const mint& m) {
    os << m.val();
    return os;
}

template <class T>
using pq = priority_queue<T, vector<T> >;
template <class T>
using pq_g = priority_queue<T, vector<T>, greater<T> >;

template <class T>
using vc = vector<T>;
using pii = pair<int, int>;
using pll = pair<long long, long long>;

#define rep(i, n) for (ll i = 0; i < (n); ++i)
template <class T>
istream& operator>>(istream& i, vector<T>& v) {
    rep(j, size(v)) i >> v[j];
    return i;
}

const int inf = 1073741823;
const ll infl = 1LL << 60;

#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define drep(i, n) for (ll i = (n) - 1; i >= 0; --i)
#define nfor(i, s, n) for (ll i = s; i < n; i++)
#define dfor(i, s, n) for (ll i = (s) - 1; i >= n; i--)

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()

#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)

#define Yes cout << "Yes" << '\n'
#define No cout << "No" << '\n'
#define YN                     \
    {                          \
        cout << "Yes" << '\n'; \
    }                          \
    else {                     \
        cout << "No" << '\n';  \
    }  // if(a==b)YN;

#define vc_unique(v) v.erase(unique(v.begin(), v.end()), v.end());

#define pop_cnt(s) ll(popcount(uint64_t(s)))

#define next_p(v) next_permutation(v.begin(), v.end())

vector<int> dx = {-1, -1, 0, 0, 1, 1, 1};  // vl dx={1,1,0,-1,-1,-1,0,1};
vector<int> dy = {0, 1, -1, 1, -1, 0, 1};  // vl dy={0,1,1,1,0,-1,-1,-1};

bool out_grid(ll i, ll j, ll h, ll w = -1) {
    if (w == -1) {
        w = h;
    }
    return (!(0 <= i && i < h && 0 <= j && j < w));
}

#define euclid(x, y) ((x) * (x) + (y) * (y))  // ユークリッド距離 2乗のまま
#define manhattan(x1, x2, y1, y2) \
    (abs(x1 - x2) + abs(y1 - y2))  // マンハッタン距離 = |x1-x2|+|y1-y2|

ll nc2(ll x) { return x * (x - 1) / 2; }
ll nc3(ll x) { return x * (x - 1) * (x - 2) / 6; }

//----------------------------------------------

//-----------6.デバックや出力系------------------

#define print_vec(v)                                       \
    {                                                      \
        ll n = size(v);                                    \
        rep(i, n) cout << v[i] << (i == n - 1 ? "" : " "); \
        cout << '\n';                                      \
    }  // 一次元配列を出力する(改行なし)

#define vc_cout(v)                      \
    {                                   \
        ll n = size(v);                 \
        rep(i, n) cout << v[i] << '\n'; \
    }  // 一次元配列を出力する(改行あり)
#define vv_cout(v)                                                   \
    {                                                                \
        ll n = size(v);                                              \
        rep(i, n) {                                                  \
            rep(j, size(v[i])) {                                     \
                cout << v[i][j] << (j == size(v[i]) - 1 ? "" : " "); \
            }                                                        \
            cout << '\n';                                            \
        }                                                            \
    }  // 二次元配列を出力する
//----------------------------------------------

long long llpow(long long a, long long n) {
    long long res = 1;
    while (n > 0) {
        if (n & 1) res = res * a;
        a = a * a;
        n >>= 1;
    }
    return res;
}

long long modpow(long long a, long long n, long long mod) {
    long long res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

long long modinv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while (b) {
        long long t = a / b;
        a -= t * b;
        swap(a, b);
        u -= t * v;
        swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}

int NCK_MOD;
vector<long long> fact, fact_inv, inv;

/*  init_nCk :二項係数のための前処理
    計算量:O(n)
*/
void init_nCk(int SIZE, int MOD) {
    NCK_MOD = MOD;
    fact.resize(SIZE + 5);
    fact_inv.resize(SIZE + 5);
    inv.resize(SIZE + 5);
    fact[0] = fact[1] = 1;
    fact_inv[0] = fact_inv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < SIZE + 5; i++) {
        fact[i] = fact[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
        fact_inv[i] = fact_inv[i - 1] * inv[i] % MOD;
    }
}

/*  nCk :MODでの二項係数を求める(前処理 int_nCk が必要)
    計算量:O(1)
*/
long long nCk(int n, int k) {
    if (n < k || n < 0 || k < 0) return 0;
    return fact[n] * (fact_inv[k] * fact_inv[n - k] % NCK_MOD) % NCK_MOD;
}

void _main();
signed main() {
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    _main();
    return 0;
}

#endif