Language: C++

#![allow(dead_code,unused_variables)]
use proconio::{fastout, input};

fn pow(x : usize, k:usize, m: usize) -> i64{
    let mut res = 1;
    let mut n = k;
    let mut a = x;
    while n > 0{
        if n&1 == 1{
            res = (res * a)%m;
        }
        a = (a * a)% m;
        n >>= 1;
    }
    res as i64
}

#[fastout]
fn main() {
    input!{
        p: usize,
        a:[i64;p-1],
    }

    let mut b : Vec<i64> = vec![0;p as usize];
    let pp = p as i64;
    let c = Combination::new(p+1,p);
    for i in 0..(p-1){
        b[0] = (b[0] + a[i])%pp;
        if i==0{
            if a[i] == 1{
                b[p-1] -= 1;
            }
            if b[p-1] < 0{
                b[p-1] += pp;
            }
        }else{
            if a[i] == 0{
                continue;
            }
            for j in 0..p{
                let d = (c.comb(p-1,j) * pow(i,p-1-j,p))%pp;
                // println!("{} comb : {} pow ; {}",d,c.comb(p-1,j),pow(i,p-1-j,p));
                if (p-1-j)%2 == 1{
                    b[j] += d;
                }else{
                    b[j] -= d;
                }
                b[j] %= pp;
                if b[j] < 0{
                    b[j] += pp;
                }
            }
        }     
    }


    for i in 0..p{
        if i>0{
            print!(" ");
        }
        print!("{}",b[i]%pp);
    }
    println!("");
}

pub struct Combination{
    fac : Vec<usize>,
    finv : Vec<usize>,
    m : usize,
}

impl Combination{
    pub fn new(n : usize, m : usize) -> Self{
        let mut inv = vec![1;n+1];
        let mut fac = vec![1;n+1];
        let mut finv = vec![1;n+1];

        for i in 2..(n+1){
            fac[i] = (fac[i-1] * i) % m;
            inv[i] = m - (inv[m%i] * (m/i) % m);
            finv[i] = (finv[i-1]*inv[i])%m;
        }

        Combination{
            fac,
            finv,
            m,
        }
    }

    pub fn comb(&self, n : usize, k: usize) -> i64{
        if n < k{
            return 0;
        }

        ((self.fac[n] * (self.finv[k] * self.finv[n-k] % self.m)) % self.m )as i64
    }
}

Compiler output:
a.cc:1:2: error: invalid preprocessing directive #!
    1 | #![allow(dead_code,unused_variables)]
      |  ^
a.cc:18:2: error: invalid preprocessing directive #[
   18 | #[fastout]
      |  ^
a.cc:28:14: error: too many decimal points in number
   28 |     for i in 0..(p-1){
      |              ^~~
a.cc:41:22: error: too many decimal points in number
   41 |             for j in 0..p{
      |                      ^~~~
a.cc:58:14: error: too many decimal points in number
   58 |     for i in 0..p{
      |              ^~~~
a.cc:79:18: error: too many decimal points in number
   79 |         for i in 2..(n+1){
      |                  ^~~
a.cc:2:1: error: 'use' does not name a type
    2 | use proconio::{fastout, input};
      | ^~~
a.cc:4:1: error: 'fn' does not name a type
    4 | fn pow(x : usize, k:usize, m: usize) -> i64{
      | ^~
a.cc:19:1: error: 'fn' does not name a type
   19 | fn main() {
      | ^~
a.cc:67:1: error: 'pub' does not name a type
   67 | pub struct Combination{
      | ^~~
a.cc:73:1: error: 'impl' does not name a type
   73 | impl Combination{
      | ^~~~