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: Time Limit Exceeded)

use std::io::{self, BufRead};

fn pow(n: usize, p: usize, m: usize) -> usize {
  let mut q = p;
  let mut r = n;
  let mut result = 1;
  while q > 0 {
    if q % 2 == 1 {
      result = result * r % m;
    }
    r = r * r % m;
    q >>= 1;
  }
  result
}

fn div(n: usize, m: usize, p: usize) -> usize {
  n * pow(m, p - 2, p) % p
}

fn main() {
  let stdin = io::stdin();
  let mut lines = stdin.lock().lines();
  let p: usize = lines.next().unwrap().unwrap().parse().unwrap();
  let zs: Vec<usize> = lines.next().unwrap().unwrap().split(' ').map(|x| x.parse().unwrap()).collect();
  let mut xss: Vec<Vec<usize>> = vec![vec![0; p + 1]; p];
  xss[0][0] = 1;
  xss[0][p] = zs[0];
  for i in 1..p {
    let mut x = 1;
    for j in 0..p {
      xss[i][j] = x;
      x = x * i % p;
    }
    xss[i][p] = zs[i];
  }
  for i in 0..p {
    if xss[i][i] != 1 {
      let d = xss[i][i];
      for j in i..(p+1) {
        xss[i][j] = div(xss[i][j], d, p);
      }
    }
    for j in (i+1)..p {
      let m = xss[j][i];
      for k in i..(p+1) {
        xss[j][k] = (xss[j][k] + (p - (m * xss[i][k] % p))) % p;
      }
    }
  }
  for i in 0..p {
    let k = p - i - 1;
    for j in (i+1)..p {
      let l = p - j - 1;
      let m = xss[l][k];
      for q in k..(p+1) {
        xss[l][q] = (xss[l][q] + (p - (m * xss[k][q] % p))) % p;
      }
    }
  }
  for i in 0..p {
    print!("{} ", xss[i][p]);
  }
  println!();
}