Problem:
Score : 600 points

Problem Statement

Given are a prime number p and a sequence of p integers a_0, \ldots, a_{p-1} consisting of zeros and ones.

Find a polynomial of degree at most p-1, f(x) = b_{p-1} x^{p-1} + b_{p-2} x^{p-2} + \ldots + b_0, satisfying the following conditions:

For each i (0 \leq i \leq p-1), b_i is an integer such that 0 \leq b_i \leq p-1.

For each i (0 \leq i \leq p-1), f(i) \equiv a_i \pmod p.

Constraints

2 \leq p \leq 2999

p is a prime number.

0 \leq a_i \leq 1

Input

Input is given from Standard Input in the following format:

p
a_0 a_1 \ldots a_{p-1}

Output

Print b_0, b_1, \ldots, b_{p-1} of a polynomial f(x) satisfying the conditions, in this order, with spaces in between.

It can be proved that a solution always exists. If multiple solutions exist, any of them will be accepted.

Sample Input 1

2
1 0

Sample Output 1

1 1

f(x) = x + 1 satisfies the conditions, as follows:

f(0) = 0 + 1 = 1 \equiv 1 \pmod 2

f(1) = 1 + 1 = 2 \equiv 0 \pmod 2

Sample Input 2

3
0 0 0

Sample Output 2

0 0 0

f(x) = 0 is also valid.

Sample Input 3

5
0 1 0 1 0

Sample Output 3

0 2 0 1 3

Solution in Rust (1.15.1) (judge verdict: Accepted)

fn read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

fn vec<T, F: FnMut(usize) -> T>(n: usize, mut f: F) -> Vec<T> {
    (0..n).map(|i| f(i)).collect()
}

fn main() {
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let p: usize = scan(tokens);
    let a: Vec<usize> = vec(p, |_| scan(tokens));
    let mut prod: Vec<usize> = vec![1];
    for i in 0..p {
        prod = mul(prod, vec![i, 1], p);
    }
    let mut factorial = 1;
    for i in 1..p {
        factorial = factorial * i % p;
    }
    let factorial_inverse = inverse(factorial, p);
    let mut b = vec![0; p];
    for i in 0..p {
        if a[i] == 1 {
            let f = div(prod.clone(), i, p);
            for j in 0..p {
                b[j] = (b[j] + factorial_inverse * f[j]) % p;
            }
        }
    }
    for i in 0..p {
        if i != 0 {
            print!(" ");
        }
        print!("{}", b[i]);
    }
    println!("");
}

fn mul(f: Vec<usize>, g: Vec<usize>, p: usize) -> Vec<usize> {
    let mut h = vec![0; f.len() + g.len() - 1];
    for i in 0..f.len() {
        for j in 0..g.len() {
            h[i + j] = (h[i + j] + f[i] * g[j]) % p;
        }
    }
    h
}

fn div(mut f: Vec<usize>, a: usize, p: usize) -> Vec<usize> {
    let mut h = vec![0; f.len() - 1];
    for i in (1..f.len()).rev() {
        h[i - 1] = f[i];
        f[i - 1] = (f[i - 1] + a * f[i]) % p;
    }
    // assert_eq!(f[0], 0);
    h
}

fn power(mut b: usize, mut e: usize, p: usize) -> usize {
    let mut a = 1;
    while e != 0 {
        if e & 1 != 0 {
            a = a * b % p;
        }
        b = b * b % p;
        e >>= 1;
    }
    a
}

fn inverse(x: usize, p: usize) -> usize {
    power(x, p - 2, p)
}