{$mode objfpc}
{$R-,Q-,H-,S-,I-}

const           InputFile               =       '';
                OutputFile              =       '';
                maxN                    =       trunc( 5E5 ) + 10;
                maxD                    =       trunc( 1E12 );


var             n , i , j , u , x       :       integer;
                count                   :       integer;
                res                     :       int64;
                d                       :       array [0 .. maxN] of int64;
                prev , next , id        :       array [0 .. maxN] of integer;
                avail                   :       array [0 .. maxN] of boolean;


procedure Sort( l , h : integer );
        var     i , j   :       integer;
                pivot   :       integer;
                tmp     :       integer;
        begin
                if l >= h then exit;
                i := l; j := h;
                pivot := d[id[random( h - l + 1 ) + l]];
                repeat
                        while d[id[i]] < pivot do inc( i );
                        while d[id[j]] > pivot do dec( j );
                        if i <= j then
                                begin
                                        tmp := id[i];
                                        id[i] := id[j];
                                        id[j] := tmp;
                                        inc( i ); dec( j );
                                end;
                until i > j;
                Sort( l , j ); Sort( i , h );
        end;


begin
                assign( input , InputFile ); reset( input );
                assign( output , OutputFile ); rewrite( output );
                readln( n );
                randomize; d[0] := maxD + 1; d[n + 1] := maxD + 1;
                for i := 1 to n do
                        begin
                                readln( d[i] );
                                Id[i] := i;
                                prev[i] := i - 1;
                                next[i] := i + 1;
                        end;
                Sort( 1 , n );
                fillchar( avail , sizeof( avail ) , true );
                for x := 1 to n do
                if avail[id[x]] then
                        begin
                                u := id[x]; count := 1;
                                i := prev[u]; j := next[u];
                                while d[i] <= d[u] do
                                        begin
                                                inc( count );
                                                avail[i] := false;
                                                i := prev[i];
                                        end;
                                while d[j] <= d[u] do
                                        begin
                                                inc( count );
                                                avail[j] := false;
                                                j := next[j];
                                        end;
                                next[i] := j; prev[j] := i;
                                if i > 0 then res := res + count;
                                if j <= n then res := res + count;
                                res := res + int64( count * ( count - 1 ) ) div 2;
                        end;
                writeln( res );
end.