struct BIT {
    bit: Vec<i64>,
    n: usize,
}

impl BIT {
    fn new(n: usize) -> BIT {
        BIT {
            bit:vec![0; n + 1],
            n: n,
        }
    }

    fn sum(&self, i: usize) -> i64 {
        let mut i = i;
        let mut s: i64 = 0;
        while i > 0 {
            s += self.bit[i];
            i -= (i as i64 & -(i as i64)) as usize;
        }
        s
    }

    fn add(&mut self, i: usize, x: i64) {
        let mut i = i;
        while i <= self.n {
            self.bit[i as usize] += x;
            i += (i as i64 & -(i as i64)) as usize;
        }
    }
 }

fn count_inversion(xs: &Vec<usize>) -> i64 {
    let mut cnt = 0;
    let mut bt = BIT::new(xs.len());
    for i in 0..xs.len() {
        cnt += i as i64 - bt.sum(xs[i]);
        bt.add(xs[i], 1);
    }
    cnt
}

fn main() {
    let mut n = String::new();
    std::io::stdin().read_line(&mut n).ok();
    let n: usize = n.trim().parse().unwrap();
    let mut p = String::new();
    std::io::stdin().read_line(&mut p).ok();
    let p: Vec<usize> = p.trim().split_whitespace()
        .map(|x| x.parse().unwrap()).collect();

    println!("{}", count_inversion(&p));
}