#![allow(non_upper_case_globals, unused_imports)]

use std::cmp::{max, min};
use std::collections::BTreeMap;
use std::io::{self, BufRead, Write};

const sz: usize = 2e6 as usize + 10;
static mut size: usize = 0;
static mut last: usize = 0;
static mut ans: u64 = 0;
static mut fa: [usize; sz] = [0; sz];
static mut len: [usize; sz] = [0; sz];
static mut ch: Vec<BTreeMap<usize, usize>> = Vec::new();
static mut null: usize = 0;

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();
    unsafe {
        solve(stdin.lock(), stdout.lock());
    }
}

unsafe fn solve<R, W>(mut input: R, mut output: W)
where
    R: BufRead,
    W: Write,
{
    let mut buf = String::new();
    input.read_line(&mut buf).unwrap();
    buf.clear();
    ch.resize(sz, BTreeMap::new());
    input.read_line(&mut buf).unwrap();
    let arg: Vec<usize> = buf
        .split_whitespace()
        .map(|s| s.parse::<usize>().unwrap())
        .collect();
    size = 1;
    last = 1;
    for i in arg.iter() {
        insert(*i);
        writeln!(output, "{}", ans).unwrap();
    }
}

unsafe fn insert(x: usize) {
    size += 1;
    let np = size;
    let mut p = last;
    last = np;
    len[last] = len[p] + 1;
    let q;
    while p != null && ch[p].get(&x) == None {
        ch[p].insert(x, np);
        p = fa[p];
    }
    if p == null {
        fa[size] = 1;
    } else {
        q = *ch[p].get(&x).unwrap();
        if len[q] == len[p] + 1 {
            fa[np] = q;
        } else {
            size += 1;
            let nq = size;
            len[nq] = len[p] + 1;
            fa[nq] = fa[q];
            fa[q] = nq;
            fa[np] = nq;
            ch[nq] = ch[q].clone();
            while p != null && ch[p].get(&x) == Some(&q) {
                ch[p].insert(x, size);
                p = fa[p];
            }
        }
    }
    ans += (len[np] - len[fa[np]]) as u64;
}