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)

use std::io::Read;
use std::cmp::min;

fn pow(x: &Vec<i32>, n:&i32, p:&i32) -> Vec<i32>{
    if n == &1{
        x.clone()
    }
    else if n % 2 == 0{
        let half = pow(x, &(n / 2), &p);
        mult(&half, &half, &p)
    }
    else{
        let dec = pow(&x, &(n-1), &p);
        mult(&x, &dec, &p)
    }
}

fn mult(x: &Vec<i32>, y: &Vec<i32>, p:&i32)->Vec<i32>{
    let degx = x.len();
    let degy = y.len();
    let mut z = vec![0;min(degx+degy-1, *p as usize)];
    for i in 0..degx{
        for j in 0..degy{
            let mut k = (i + j) as i32;
            while k >= *p{
                k -= p-1;
            }
            z[k as usize] += x[i as usize] * y[j as usize];
            z[k as usize] %= *p;
        }
    }
    z
}

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();
    let mut ans = vec![1];
    let p: i32 = iter.next().unwrap().parse().unwrap();
    for i in 0..p{
        let a: i32 = iter.next().unwrap().parse().unwrap();
        if a == 0{
            ans = mult(&ans, &vec![p-i, 1], &p);
        }
    }
    ans = pow(&ans, &(p-1), &p);
    while ans.len() < (p as usize){
        ans.push(0);
    }
    println!("{}", ans.into_iter().map(|x| {x.to_string()}).collect::<Vec<String>>().join(" "));
    
}