// reference: https://github.com/atcoder/ac-library
#[allow(dead_code)]
mod segtree {
    pub struct Segtree<T, O, E> {
        n: usize, len: usize, height: usize,
        op: O, e: E,
        node: Vec<T>,
    }

    impl<T, O, E> Segtree<T, O, E>
    where
        T: Clone + Copy,
        O: Fn(T, T) -> T, E: Fn() -> T,
    {
        pub fn new(n: usize, op: O, e: E) -> Self {
            let (mut len, mut height) = (1, 1);
            while len < n {
                len *= 2;
                height += 1;
            }
            let node = vec![e(); 2 * len];
            Self { n, len, height, op, e, node }
        }

        pub fn from(v: &[T], op: O, e: E) -> Self {
            let mut st = Self::new(v.len(), op, e);
            for i in 0..v.len() { st.node[i + st.len] = v[i]; }
            for i in (1..st.len).rev() { st.update(i); }
            st
        }

        fn update(&mut self, k: usize) {
            self.node[k] = (self.op)(self.node[2 * k], self.node[2 * k + 1]);
        }

        pub fn set(&mut self, mut p: usize, x: T) {
            assert!(p < self.n);
            p += self.len;
            self.node[p] = x;
            for i in 1..self.height { self.update(p >> i) };
        }

        pub fn get(&self, p: usize) -> T {
            assert!(p < self.n);
            self.node[p + self.len]
        }

        pub fn prod(&self, mut l: usize, mut r: usize) -> T {
            assert!(l <= r && r <= self.n);
            let (mut sml, mut smr) = ((self.e)(), (self.e)());
            l += self.len;
            r += self.len;

            while l < r {
                if l & 1 != 0 {
                    sml = (self.op)(sml, self.node[l]);
                    l += 1;
                }
                if r & 1 != 0 {
                    r -= 1;
                    smr = (self.op)(self.node[r], smr);
                }
                l >>= 1;
                r >>= 1;
            }

            (self.op)(sml, smr)
        }

        pub fn all_prod(&self) -> T {
            self.node[1]
        }

        pub fn max_right<F: Fn(T) -> bool>(&self, mut l: usize, f: F) -> usize {
            assert!(l <= self.n);
            assert!(f((self.e)()));
            if l == self.n { return self.n; }
            l += self.len;
            let mut sm = (self.e)();
            while {
                while l % 2 == 0 { l >>= 1; }
                if !f((self.op)(sm, self.node[l])) {
                    while l < self.len {
                        l = 2 * l;
                        if f((self.op)(sm, self.node[l])) {
                            sm = (self.op)(sm, self.node[l]);
                            l += 1;
                        }
                    }
                    return l - self.len;
                }
                sm = (self.op)(sm, self.node[l]);
                l += 1;
                (l & (!l + 1)) != l
            } {}
            self.n
        }

        pub fn min_left<F: Fn(T) -> bool>(&self, mut r: usize, f: F) -> usize {
            assert!(r <= self.n);
            assert!(f((self.e)()));
            if r == 0 { return 0; }
            r += self.len;
            let mut sm = (self.e)();
            while {
                r -= 1;
                while r > 1 && r % 2 != 0 { r >>= 1; }
                if !f((self.op)(self.node[r], sm)) {
                    while r < self.len {
                        r = 2 * r + 1;
                        if f((self.op)(self.node[r], sm)) {
                            sm = (self.op)(self.node[r], sm);
                            r -= 1;
                        }
                    }
                    return r + 1 - self.len;
                }
                sm = (self.op)(self.node[r], sm);
                (r & (!r + 1)) != r
            } {}
            0
        }
    }
}

use segtree::Segtree;

type T = [u32; 3];

const INF: u32 = 1 << 30;

fn run<'a, F: FnMut() -> &'a str, W: std::io::Write>(scan: &mut F, writer: &mut W) {
    macro_rules! scan {
        ([$t:tt; $n:expr]) => ((0..$n).map(|_| scan!($t)).collect::<Vec<_>>());
        (($($t:tt),*)) => (($(scan!($t)),*));
        (Usize1) => (scan!(usize) - 1);
        (Bytes) => (scan().as_bytes().to_vec());
        ($t:ty) => (scan().parse::<$t>().unwrap());
    }
    macro_rules! println {
        ($($arg:tt)*) => (writeln!(writer, $($arg)*).ok());
    }

    let n = scan!(usize);
    let a = scan!([u32; n]);

    let v = a.into_iter().map(|a| [a, INF, a]).collect::<Vec<_>>();
    let op = |a: T, b: T| {
        [
            a[0].min(b[0]),
            if a[0] < b[0] {
                *[a[1], b[0], b[1]].iter().min().unwrap()
            } else {
                *[a[0], a[1], b[1]].iter().min().unwrap()
            },
            a[2].max(b[2]),
        ]
    };
    let e = || [INF, INF, 0];
    let seg = Segtree::from(&v, op, e);

    let mut ans = 0;
    for l in 0..n {
        let f = |x: T| x[2] <= x[0] + x[1];
        let r = seg.max_right(l, f);
        ans += r - l - 1;
    }
    println!("{}", ans);
}

fn main() {
    let ref mut buf = Vec::new();
    std::io::Read::read_to_end(&mut std::io::stdin(), buf).ok();
    let mut iter = unsafe {
        std::str::from_utf8_unchecked(buf).split_ascii_whitespace()
    };
    let ref mut scan = || iter.next().unwrap();

    let stdout = std::io::stdout();
    let ref mut writer = std::io::BufWriter::new(stdout.lock());

    run(scan, writer);
}