jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
use std::io::stdin;

fn main() {
    let result:Vec<i32> = [1, 9, 30, 76, 141, 267, 400, 624, 885, 1249, 1590, 2208, 2689, 3411, 4248, 5248, 6081, 7485, 8530, 10248, 11889, 13687, 15228, 17988, 20053, 22569, 25242, 28588, 31053, 35463, 38284, 42540, 46581, 50893, 55362, 61824, 65857, 71247, 76884, 84388, 89349, 97881, 103342, 111528, 120141, 128047, 134580, 146316, 154177, 164817, 174438, 185836, 194157, 207927, 218812, 233268, 245277, 257857, 268182, 288216, 299257, 313635, 330204, 347836, 362973, 383709, 397042, 416448, 434025, 456967, 471948, 499740, 515581, 536073, 559758, 583960, 604833, 633651, 652216, 683712, 709065, 734233, 754734, 793188, 818917, 846603, 874512, 909496, 933081, 977145, 1006126, 1041504, 1073385, 1106467, 1138536, 1187112, 1215145, 1255101, 1295142, 1342852, 1373253, 1422195, 1453816, 1502376, 1553361, 1595437, 1629570, 1691292, 1726717, 1782111, 1827492, 1887772, 1925853, 1986837, 2033674, 2089776, 2145333, 2197483, 2246640, 2332104, 2379085, 2434833, 2490534, 2554600, 2609625, 2693919, 2742052, 2813988, 2875245, 2952085, 3003306, 3096024, 3157249, 3224511, 3306240, 3388576, 3444609, 3533637, 3591322, 3693924, 3767085, 3842623, 3912324, 4027884, 4102093, 4181949, 4270422, 4361548, 4427853, 4548003, 4616104, 4718640, 4812789, 4918561, 5003286, 5131848, 5205481, 5299011, 5392008, 5521384, 5610705, 5739009, 5818390, 5930196, 6052893, 6156139, 6239472, 6402720, 6493681, 6623853, 6741078, 6864016, 6953457, 7094451, 7215016, 7359936, 7475145, 7593865, 7689630, 7886244, 7984165, 8130747, 8253888, 8403448, 8523897, 8684853, 8802826, 8949612, 9105537, 9267595, 9376656, 9574704, 9686065, 9827097, 9997134, 10174780, 10290813, 10493367, 10611772, 10813692].to_vec();
    let mut st = String::new();
    stdin().read_line(&mut st).unwrap();
    let k = st.trim().parse::<usize>().unwrap();
    println!("{:?}",result[k-1]);
}
//  [rust]
// ---------- begin ModInt ----------
const MOD: u32 = 1_000_000_007;

#[derive(Clone, Copy)]
struct ModInt(u32);

impl std::ops::Add for ModInt {
    type Output = ModInt;
    fn add(self, rhs: ModInt) -> Self::Output {
        let mut d = self.0 + rhs.0;
        if d >= MOD {
            d -= MOD;
        }
        ModInt(d)
    }
}

impl std::ops::AddAssign for ModInt {
    fn add_assign(&mut self, rhs: ModInt) {
        *self = *self + rhs;
    }
}

impl std::ops::Sub for ModInt {
    type Output = ModInt;
    fn sub(self, rhs: ModInt) -> Self::Output {
        let mut d = self.0 + MOD - rhs.0;
        if d >= MOD {
            d -= MOD;
        }
        ModInt(d)
    }
}

impl std::ops::SubAssign for ModInt {
    fn sub_assign(&mut self, rhs: ModInt) {
        *self = *self - rhs;
    }
}

impl std::ops::Mul for ModInt {
    type Output = ModInt;
    fn mul(self, rhs: ModInt) -> Self::Output {
        ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)
    }
}

impl std::ops::MulAssign for ModInt {
    fn mul_assign(&mut self, rhs: ModInt) {
        *self = *self * rhs;
    }
}

impl std::ops::Neg for ModInt {
    type Output = ModInt;
    fn neg(self) -> Self::Output {
        ModInt(if self.0 == 0 {0} else {MOD - self.0})
    }
}

impl std::fmt::Display for ModInt {
    fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl std::str::FromStr for ModInt {
    type Err = std::num::ParseIntError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let val = s.parse::<u32>()?;
        Ok(ModInt::new(val))
    }
}

impl From<usize> for ModInt {
    fn from(val: usize) -> ModInt {
        ModInt((val % MOD as usize) as u32)
    }
}

#[allow(dead_code)]
impl ModInt {
    pub fn new(n: u32) -> ModInt {
        ModInt(n % MOD)
    }
    pub fn zero() -> ModInt {
        ModInt(0)
    }
    pub fn one() -> ModInt {
        ModInt(1)
    }
    pub fn pow(self, mut n: u32) -> ModInt {
        let mut t = ModInt::one();
        let mut s = self;
        while n > 0 {
            if n & 1 == 1 {
                t *= s;
            }
            s *= s;
            n >>= 1;
        }
        t
    }
    pub fn inv(self) -> ModInt {
        assert!(self.0 > 0);
        self.pow(MOD - 2)
    }
}
// ---------- end ModInt ----------

use proconio::*;

fn run() {
    input! {
        k: usize,
    }
    let n = 3;
    let mut memo = vec![ModInt::zero(); k + 1];
    for i in (1..=k).rev() {
        let mut way = ModInt::from(k / i).pow(n);
        let mut j = 2 * i;
        while let Some(&v) = memo.get(j) {
            way -= v;
            j += i;
        }
        memo[i] = way;
    }
    let mut ans = ModInt::zero();
    for (i, c) in memo.into_iter().enumerate() {
        ans += ModInt::from(i) * c;
    }
    println!("{}", ans);
}

fn main() {
    run();
}
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;
use num::integer::gcd;

fn main() {
    input! {
        n: u64
    }

    let mut r = 0;

    for i in 1..=n {
        for j in 1..n {
            for k in 1..n {
                r += gcd(gcd(i, j), k);
            }
        }
    }

    println!("{}", r);
}
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;
use num::integer;

fn main() {
    input! {
        n: u64
    }

    let mut r = 0;

    for i in 1..=n {
        for j in 1..n {
            for k in 1..n {
                r += gcd(gcd(i, j), k);
            }
        }
    }

    println!("{}", r);
}
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;
use num::integer::gcd;

fn main() {
    input! {
        n: u64
    }

    let mut r = 0;

    for i in 1..n {
        for j in 1..n {
            for k in 1..n {
                r += gcd(gcd(i, j), k);
            }
        }
    }

    println!("{}", r);
}
//  [swift]
func gcd(_ a: Int, _ b: Int) -> Int {
    guard b != 0 else { return a }

    let r = a % b
    if r > b - r {
        return gcd(b, b - r)
    } else {
        return gcd(b, r)
    }
}

func gcd(_ a: Int, _ b: Int, _ c: Int) -> Int {
    gcd(gcd(a, b), c)
}

let N = Int(readLine()!)!

var sum0 = 0
for i in 1 ... N {
    guard i + 1 <= N else { continue }
    for j in i + 1 ... N {
        guard j + 1 <= N else { continue }
        for k in j + 1 ... N {
            sum0 += gcd(i, j, k)
        }
    }
}

var sum1 = 0
for i in 1 ... N {
    guard i + 1 <= N else { continue }
    for j in i + 1 ... N {
        sum1 += gcd(i, i, j)
        sum1 += gcd(i, j, j)
    }
}

var sum2 = 0
for i in 1 ... N {
    sum2 += gcd(i, i, i)
}

print(sum0 * 6 + sum1 * 3 + sum2)
//  [swift]
// Your code here!
func gcd(_ a: Int, _ b: Int) -> Int {
   let r = a % b
   if r != 0 {
       return gcd(b, r)
   } else {
       return b
   }
}
var num = Int(readLine()!)!
var ans:Int = 0
for i in 1...num{
    for j in 1...num{
        for k in 1...num{
        var n:Int = 0
            n += gcd(i,j)
            ans += gcd(k,n)
        }
    }
}
print(ans)
//  [swift]
// Sum of gcd of Tuples (Easy)
func gcd(_ a:Int, _ b:Int) -> Int {
  if a == 1 || b == 1 {
    return 1
  }
  if a == b {
    return a
  }
  return gcd(min(a, b), abs(b-a))
}


func main() {
  let n = Int(readLine()!)!
  var sum = 0
  for a in 1...n {
    for b in 1...n {
      for c in 1...n {
        sum += gcd(gcd(a,b), c)
      }
    }
  }
  print(sum)
}

main()
//  [swift]
let K = Int(readLine()!)!
var res: Int = 0

for a in 1...K {
    for b in a...K {
        for c in b...K {
            if Set([a, b, c]).count == 3 {
                res += gcd(gcd(a, b), c) * 6
            } else if Set([a, b, c]).count == 2 {
                res += gcd(gcd(a, b), c) * 3
            } else {
                res += gcd(gcd(a, b), c)
            }
        }
    }
}
print(res)  // (๑•ૅㅁ•๑)
//  [swift]
import Foundation

let main: () = {
    let K = 200 //getInt()
    var ans = 0
    for a in 1...K {
    for b in 1...K {
    for c in 1...K {
        ans += gcd(gcd(a, b), c)
    }}}
    print(ans)
}()

func gcd(_ a: Int, _ b: Int) -> Int { (b > 0) ? gcd(b, a % b) : a }

func getString() -> String { readLine()! }
func getInt() -> Int { Int(getString())! }
func getDouble() -> Double { Double(getString())! }
//  [swift]
func gcd(_ a: Int, _ b: Int) -> Int {
    guard b != 0 else { return a }
    return gcd(b, a % b)
}

func gcda(_ s: [Int]) -> Int {
    guard !s.isEmpty else { return 0 }
    guard s.count > 1 else { return s.first! }

    var tmpS = s
    let first = tmpS.removeFirst()
    return tmpS.reduce(first) { gcd($0, $1) }
}

func memoize(_ f: @escaping ([Int]) -> Int) -> ([Int]) -> Int {
    var dic = [[Int] : Int]()
    return { nums in
        if let value = dic[nums.sorted()] {
            return value
        } else {
            let result = f(nums)
            dic[nums] = result
            return result
        }
    }
}

let m_gcda = memoize(gcda)

let k = Int(readLine()!)!

var results = [Int]()
for a in 1...k {
    for b in 1...k {
        for c in 1...k {
            results.append(m_gcda([a, b, c]))
        }
    }
}

let sum = results.reduce(into: 0) { $0 += $1 }
print(sum)
//  [typescript]
class NormalInput {
  input: string[];
  pointer: number;
  constructor(raw: string) {
    this.input = raw.split(/ |\n/);
    this.pointer = 0;
  }
  int = (): number => {
    const ret = parseInt(this.input[this.pointer], 10);
    this.pointer++;
    return ret;
  };
  str = (): string => {
    const ret = this.input[this.pointer];
    this.pointer++;
    return ret;
  };
  strs = (length: number): string[] => {
    let ret: string[] = [];
    for (let i = 0; i < length; i++) {
      ret.push(this.str());
    }
    return ret;
  };
  ints = (length: number): number[] => {
    let ret: number[] = [];
    for (let i = 0; i < length; i++) {
      ret.push(this.int());
    }
    return ret;
  };
}
function rep(a: number, b: number) {
  let arr = [];
  for (let i = a; i < b; i++) arr.push(i);
  return arr;
}
function gcd(a: number, b: number) {
  if (a == 0) return b;
  return gcd(b % a, a);
}
function Main({ int, str, strs, ints }: NormalInput) {
  const K = int();
  let sum = 0;
  for (let a = 0; a < K; a++)
    for (let b = 0; b < K; b++) {
      const gcdAB = gcd(a+1, b+1);
      for (let c = 0; c < K; c++) {
        const gcdABC = gcd(gcdAB, c+1);
        sum += gcdABC;
      }
    }
  console.log(sum);
}

//DO NOT EDIT
Main(new NormalInput(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
import * as fs from "fs";

const memo: Array<Array<number>> = [];
function gcd(x: number, y: number): number {
	if (y === 0) return x;
	if (memo[y] === undefined) memo[y] = [];
	if (memo[y][x] === undefined) {
		return memo[y][x] = gcd(y, x % y);
	}
	return memo[y][x];
}
const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const k = +input[0];

let result = 0;
for (let a = 1; a <= k; a++) {
	for (let b = 1; b <= k; b++) {
		const temp = gcd(Math.max(a, b), Math.min(a, b));
		for (let c = 1; c <= k; c++) {
			result += gcd(Math.max(temp, c), Math.min(temp, c));
		}
	}
}
console.log(result);
//  [typescript]
var input = process.argv[2];
var result = 0;
for (var a = 1; a <= input; a++) {
  for (var b = 1; b <= input; b++) {
    for (var c = 1; c <= input; c++) {
      // console.log(a + " " + b + " " + c);
      result += gcd(gcd(a, b), c);
    }
  }
}
console.log(result);

function gcd(a, b) {  
  if (b == 0) {
    return a;
  }
  return gcd(b, a%b);
}
//  [typescript]
import * as fs from 'fs';

function gcd(...tuple: number[]) {
    const min = Math.min(...tuple);
    let gcd = 1;
    for (let i = 2; i <= min; i++) {
        let devides = true;
        for (let value of tuple) {
            if (value % i !== 0) {
                devides = false;
                break;
            }
        }
        if (devides) {
            gcd = i;
        }
    }
    return gcd;
}

function Main(input: string) {
    const constraintK = parseInt(input);
    let sum = 0;

    for (let a = 1; a <= constraintK; a++) {
        for (let b = 1; b <= constraintK; b++) {
            for (let c = 1; c <= constraintK; c++) {
                sum += gcd(a, b, c);
            }
        }
    }

    //output
    console.log(sum);
}

Main(fs.readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from "fs";

function main(lines: string[][]) {
  const number = parseInt(lines[0][0]);
  const numbers: number[] = [];
  for (let i = 1; i <= number; i++) {
    numbers.push(i);
  }

  const permutations: number[][] = [];
  numbers.forEach((n1) => {
    numbers.forEach((n2) => {
      numbers.forEach((n3) => {
        permutations.push([n1, n2, n3]);
      });
    });
  });

  const commonDivisor = (a: number, b: number) => (b > 0 ? commonDivisor(b, a % b) : a);
  const greatestCommonDivisor = (a: number, b: number, c: number): number => {
    let result = c;
    result = commonDivisor(result, b);
    result = commonDivisor(result, a);
    return result;
  };

  const gcds = permutations.map((p) => {
    const result = greatestCommonDivisor(p[0], p[1], p[2]);
    return result;
  });

  const point = gcds.reduce((prev, cur) => prev + cur, 0);
  console.log(point);
}

const lines = fs
  .readFileSync("/dev/stdin", "utf8")
  .split("\n")
  .map((l) => l.split(" "))
  .filter((input) => !(input.length === 1 && input[0] === ""));

main(lines);
//  [python]
def main():
    N = int( input())
    A = list( map( int, input().split()))
    B = [0]*(N+1)
    for a in A:
        B[a] += 1
    print("\n".join( map( str, B[1:])))
if __name__ == '__main__':
    main()
//  [python]
def main():
    N = int( input())
    A = list( map( int, input().split()))
    B = [0]*(N)
    for a in A:
        B[a-1] += 1
    print("\n".join( map( str, B)))
if __name__ == '__main__':
    main()
//  [python]
import sys


def resolve(in_, out):
    n = int(in_.readline())
    b = [0] * (n + 1)
    for a in map(int, in_.readline().split()):
        b[a] += 1
    out.write('\n'.join(map(str, b[1:])))


def main():
    resolve(sys.stdin.buffer, sys.stdout)


if __name__ == '__main__':
    main()
//  [python]
N = int(input())
a = list(map(int, input().split()))

for i in range(1,N+1):
    count = a.count(i)
    print(count)
//  [python]
N = int(input())
A = list(map(int, input().split()))
assert len(A) == N - 1
count = [0 for i in range(len(A))]
for a in A:
  count[a] += 1
for n in range(N):
  print(count[n])
//  [python]
from collections import Counter
n=int(input())
a=list(map(int,input().split()))
for i in range(1,n+1):
  print(Counter(a)[i])
//  [java]
import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a=sc.nextInt();
		int t=0;
		int b[]=new int[a-1];
		for(int i=0;i<a-1;i++) {
			int k =sc.nextInt();
			b[k+1]++;
		}
		for(int j=0;j<a-1;j++) {	
			System.out.println(b[j]);
		}
		System.out.println(0);


	}

}
//  [java]
import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a=sc.nextInt();
		int t=0;
		int b[]=new int[a-1];
		for(int i=0;i<a-1;i++) {
			int k =sc.nextInt();
			for(int j=0;j<a-1;j++) {			
				if(j+1==k) {
					b[j]++;
				}
			}
		}
		for(int j=0;j<a-1;j++) {	
			System.out.println(b[j]);
		}
		System.out.println(0);


	}

}
//  [java]
import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a=sc.nextInt();
		int t=0;
		int b[]=new int[a];
		for(int i=0;i<a-1;i++) {
			int k =sc.nextInt();
			for(int j=0;j<a;j++) {			
				if(j+1==k) {
					b[j]++;
				}
				System.out.println(b[j]);
			}
		}
		


	}

}
//  [cpp]
#pragma GCC optimize ("Ofast")
#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please

const int CM = 440000, CL = 12;
char cn[CM + CL], * ci = cn + CM + CL, * owa = cn + CM, ct;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
	if (ci - owa > 0) {
		memcpy(cn, owa, CL);
		ci -= CM;
		fread(cn + CL, 1, CM, stdin);
	}
	ll tmp = *(ll*)ci;
	int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
	tmp = tmp << dig & ma1;
	tmp = tmp * 10 + (tmp >> 8) & ma2;
	tmp = tmp * 100 + (tmp >> 16) & ma3;
	tmp = tmp * 10000 + (tmp >> 32) & ma4;
	ci += (72 - dig >> 3);
	return tmp;
}
char* di = cn;
inline void putint(int X) {
	if (X < 10) {
		*di++ = '0' + X;
		*di++ = '\n';
		return;
	}
	int keta = 0;
	char C[10];
	while (X) {
		*(C + keta) = '0' + X % 10;
		X /= 10;
		keta++;
	}
	for (int i = keta - 1; i >= 0; i--)* di++ = (*(C + i));
	*di++ = '\n';
}

int A[200001];
int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);

	int N = getint();
	rep(i, N - 1) A[getint()]++;

	rep1(i, N) putint(A[i]);

	fwrite(cn, 1, di - cn, stdout);


	Would you please return 0;
}
//  [cpp]
#pragma GCC optimize ("Ofast")
#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please

const int CM = 1400000;
char cn[CM], * ci = cn, ct;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
	ll tmp = *(ll*)ci;
	int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
	tmp = tmp << dig & ma1;
	tmp = tmp * 10 + (tmp >> 8) & ma2;
	tmp = tmp * 100 + (tmp >> 16) & ma3;
	tmp = tmp * 10000 + (tmp >> 32) & ma4;
	ci += (72 - dig >> 3);
	return tmp;
}
char* di = cn;
inline void putint(int X) {
	if (X == 0) {
		*di++ = '0';
		*di++ = '\n';
		return;
	}
	int keta = 0;
	char C[10];
	while (X) {
		*(C + keta) = '0' + X % 10;
		X /= 10;
		keta++;
	}
	for (int i = keta - 1; i >= 0; i--)* di++ = (*(C + i));
	*di++ = '\n';
}

int A[200001];
int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);

	fread(cn, 1, CM, stdin);
	int N = getint();
	rep(i, N - 1) A[getint()]++;

	rep1(i, N) putint(A[i]);

	fwrite(cn, 1, di - cn, stdout);


	Would you please return 0;
}
//  [cpp]
#pragma GCC optimize ("Ofast")
#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please

const int CM = 1400000;
char cn[CM], * ci = cn, ct;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
	ll tmp = *(ll*)ci;
	int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
	tmp = tmp << dig & ma1;
	tmp = tmp * 10 + (tmp >> 8) & ma2;
	tmp = tmp * 100 + (tmp >> 16) & ma3;
	tmp = tmp * 10000 + (tmp >> 32) & ma4;
	ci += (72 - dig >> 3);
	return tmp;
}
char* di = cn;
inline void putint(int X) {
	if (X < 10) {
		*di++ = '0' + X;
		*di++ = '\n';
		return;
	}
	int keta = 0;
	char C[10];
	while (X) {
		*(C + keta) = '0' + X % 10;
		X /= 10;
		keta++;
	}
	for (int i = keta - 1; i >= 0; i--)* di++ = (*(C + i));
	*di++ = '\n';
}

int A[200001];
int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);

	fread(cn, 1, CM, stdin);
	int N = getint();
	rep(i, N - 1) A[getint()]++;

	rep1(i, N) putint(A[i]);

	fwrite(cn, 1, di - cn, stdout);


	Would you please return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstring>
#include <chrono>
#include <complex>
#define int long long int
#define vi vector<int>
#define vvi vector < vi >
#define pii pair<int,int>
#define mod 1000000007
#define inf 1000000000000000001
#define all(c) c.begin(),c.end()
#define mp(x,y) make_pair(x,y)
#define mem(a,val) memset(a,val,sizeof(a))
#define eb emplace_back
#define f first
#define s second
#define tr(k,st,en) for(int k = st; k <= en ; k++)
#define trb(k,en,st) for(int k = en; k >= st ; k--)
using namespace std;

//int n = 2;
//
//void add_self(int& a, int b){
//    a += b;
//    if (a >= mod) {
//        a-=mod;
//    }
//}
//
//int mul(int a, int b){
//    int c = a*b;
//    return c%mod;
//}
//
//struct M {
//    vector<vector<int>> t;
//    M(){
//        t.resize(n, vector<int>(n));
//    }
//    M operator * (M& b){
//        M c;
//        tr(i,0, n-1){
//            tr(j,0,n-1){
//                tr(k,0,n-1){
//                    add_self(c.t[i][j] , mul(t[i][k] ,b.t[k][j]));
//                }
//            }
//        }
//        return c;
//    }
//};
//M power(M x, int k){
//    M ans;
//    tr(i,0,n-1){
//        ans.t[i][i] = 1;
//    }
//    while (k) {
//        if (k%2) {
//            ans = ans * x;
//        }
//        x = x*x;
//        k/=2;
//    }
//    return ans;
//}


int32_t main()
{
    std::ios::sync_with_stdio(false);
    map<int,int> freq;
    int n,temp;
    cin>>n;
    tr(i,1,n-1){
        cin>>temp;
        freq[temp]++;
    }
    tr(i,1,n){
        auto it = freq.lower_bound(i);
        cout<< (it == freq.end() ? 0 : it->second)<<endl;
    }
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstring>
#include <chrono>
#include <complex>
#define int long long int
#define vi vector<int>
#define vvi vector < vi >
#define pii pair<int,int>
#define mod 1000000007
#define inf 1000000000000000001
#define all(c) c.begin(),c.end()
#define mp(x,y) make_pair(x,y)
#define mem(a,val) memset(a,val,sizeof(a))
#define eb emplace_back
#define f first
#define s second
#define tr(k,st,en) for(int k = st; k <= en ; k++)
#define trb(k,en,st) for(int k = en; k >= st ; k--)
using namespace std;

//int n = 2;
//
//void add_self(int& a, int b){
//    a += b;
//    if (a >= mod) {
//        a-=mod;
//    }
//}
//
//int mul(int a, int b){
//    int c = a*b;
//    return c%mod;
//}
//
//struct M {
//    vector<vector<int>> t;
//    M(){
//        t.resize(n, vector<int>(n));
//    }
//    M operator * (M& b){
//        M c;
//        tr(i,0, n-1){
//            tr(j,0,n-1){
//                tr(k,0,n-1){
//                    add_self(c.t[i][j] , mul(t[i][k] ,b.t[k][j]));
//                }
//            }
//        }
//        return c;
//    }
//};
//M power(M x, int k){
//    M ans;
//    tr(i,0,n-1){
//        ans.t[i][i] = 1;
//    }
//    while (k) {
//        if (k%2) {
//            ans = ans * x;
//        }
//        x = x*x;
//        k/=2;
//    }
//    return ans;
//}


int32_t main()
{
    std::ios::sync_with_stdio(false);
    map<int,int> freq;
    int n,temp;
    cin>>n;
    tr(i,1,n-1){
        cin>>temp;
        freq[temp] ++;
    }
    tr(i,0,n-1){
        auto it = freq.upper_bound(i);
        cout<< (it == freq.end() ? 0 : it->second)<<endl;
    }
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
#define vv(T) vector<vector<T>>
#define coa cout << ans << endl
using namespace std;
using ll = long long;
using vint = vector<int>;
using vvint = vector<vector<int>>;
using vll = vector<long long>;
using vvll = vector<vector<long long>>;
using vbool = vector<bool>;
using vvbool = vector<vector<bool>>;
using qint = queue<int>;
using sint = stack<int>;
using pii = pair<int, int>;


int main(){
    int n;
    cin >> n;
    // vector<int> buka(n, 0);
    int buka[n];
    rep(i, n - 1){
        int tmp;
        cin >> tmp;
        tmp--;
        buka[tmp]++;
    }

    rep(i, n){
        cout << buka[i] << endl;
    }
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main(){
	int n, num;
	int sum_a = 0;
	int *p;

	scanf("%d\n", &n);
	p = malloc(n * sizeof(int));
	for(int i=0; i<n; i++){
		p[i]=0;
	}
	num = n-1;
	while (0<num){
		int up_no = 0;
		char c = getchar();
		while((c!=' ') && (c!=10)){
			up_no *= 10;
			up_no += c - '0';
			c = getchar();
		}
		p[up_no-1]++;
		num--;
	}
	for(int i=0; i<n; i++){
		printf("%d\n", p[i]);
	}
	return (0);
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(void){
	int N,*A,a;
	int i;
	char str[10000000];
 
	fgets(str, sizeof(str), stdin);
	N=atoi(strtok(str," "));
	
	A = (int*)calloc(N,sizeof(int));

	fgets(str, sizeof(str), stdin);	
	a=atoi(strtok(str," "))-1;	

	A[a]+=1;
	for(i=1;i<(N-1);i++){
		a=atoi(strtok(NULL," "))-1;
		A[a]+=1;
	}

	for(i=0;i<N;i++){
		printf("%d\n",A[i]);
	}

	free(A);

	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
    int n,a[500000]={},i,sum[500000]={};
    char token[10000000]={};
    fgets(token, sizeof(token), stdin);
    n=atoi(token);
    fgets(token, sizeof(token), stdin);
    a[0]=atoi(strtok(token, " "));
    for (i=1; i<n-1; i++) a[i]=atoi(strtok(NULL, " "));
    for (i=0; i<n-1; i++) sum[a[i]]++;
    for (i=1; i<=n; i++) printf("%d\n",sum[i]);
    return 0;
}
//  [c]
#include <stdio.h>
#define true 1

int main(void)
{
    int n=0;
    int boss[200001]={};
    int bossNum[200001]={};
    scanf("%d",&n);
    for(int i=2;i<=n;i++){
        scanf("%d",&boss[i]);
        bossNum[boss[i]]+=1;
    }

    for(int i=1;i<=n;i++){
        printf("%d",bossNum[i]);
    }

    return 0;
}
//  [c]
#include <stdio.h>
 
int main(){
  int n, t;
  scanf("%d", &n);
  int a[100002]={0};
  for(int i=0; i<n-1; i++){
    scanf("%d", &t);
    a[t-1]++;
  }
  for(int i=0; i<n; i++) printf("%d\n", a[i]);
}
//  [c]
#include <stdio.h>

int main(){
  int n, t;
  scanf("%d", &n);
  int a[n]={0};
  for(int i=0; i<n-1; i++){
    scanf("%d", &t);
    a[t-1]++;
  }
  for(int i=0; i<n; i++) printf("%d\n", a[i]);
}
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n')
N = inp.shift() * 1
l = inp.shift().split(" ")
a = new Array(N)
for (i=0; i<N; i++) {
    a[i] = 0
    a[l[i] - 1] = a[l[i] - 1] + 1
}
console.log(a.join("\n"))
//  [javascript]
const Main = input => {
  const sp = input.split('\n');
  const N = Number(sp[0]);
  const A_list = sp[1].split(' ').map(e => Number(e));

  const list = new Array(N).fill(0);

  for(let i=0; i<A_list.length; i++) list[A_list[i]-1]++;

  console.log(list.join('\n'));
};

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
/*Main(`5
1 1 2 2`);
Main(`10
1 1 1 1 1 1 1 1 1`)
Main(`7
1 2 3 4 5 6`)*/
//  [javascript]
var obj = init();
Main();
function nextInt(){return myconv(next(),1);}
function nextStrArray(){return myconv(next(),2);}//半角スペース分割
function nextIntArray(){return myconv(next(),4);}//半角スペース + 数値化
function nextCharArray(){return myconv(next(),6);}//1文字分割
function next(){return obj.next();}
function hasNext(){return obj.hasNext();}
function myin(){return require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n");}
function init(){
  var inputFile = myin();
  var returnObj = {
    "list" : inputFile, "index" : 0, "max" : inputFile.length,
    "hasNext" : function(){return (this.index < this.max);},
    "next" : function(){if(!this.hasNext()){throw "ArrayIndexOutOfBoundsException これ以上ないよ";}else{var returnInput = this.list[this.index];this.index++;return returnInput;}}
  };
  return returnObj;
}
function myout(t){console.log(t);}//標準出力
function myerr(t){console.error(t);}//標準エラー出力
//[no]要素の扱い。数値型
//不明値、異常時:引数そのまま返す　1:数値へ変換
//2:半角SPで分割 4:半角SPで分割し、数値配列へ
//6:1文字で分割  7:1文字で分割し、数値配列へ
//8:半角SPで結合 9:改行で結合 0:文字なしで結合
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map((a)=>Number(a));case 6:return i.split("");case 7:return i.split("").map((a)=>Number(a));case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}
function Main(){
  var N = nextInt();
	var list = nextIntArray();
	var output = new Array(N).fill(0);
	for(var i = 0; i < N - 1; i++){
		output[list[i] - 1]++;
	}
	myout(myconv(output,9));
}
//  [javascript]
const Main = (input) => {
  const tmp = input.trim().split('\n')
  const employees = parseInt(tmp[0])
  const subordinateArray = tmp[1].split(' ')

  const subordinateCount = {}

  const distinctSubordinate = subordinateArray.filter(
    (x, i, self) => self.indexOf(x) === i
  )

  subordinateArray.forEach((elem) => {
    subordinateCount[elem] = subordinateCount[elem]
      ? subordinateCount[elem] + 1
      : 1
  })

  let result = []
  distinctSubordinate.forEach((elem) => {
    return result.push(subordinateCount[elem])
  })

  const zeroCount = employees - distinctSubordinate.length

  if (zeroCount > 0) {
    for (let index = 0; index < zeroCount; index++) {
      result.push(0)
    }
  }

  result = result.join('\n')

  console.log(result)
  return result
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split('\n');
  const a = arr[1].split(' ').map(x => Number(x));
  let count = 0;

  for (let i = 1; i < a.length + 2; i ++) {
    for (let j = 0; j < a.length; j ++) {
      if (a[j] === i) {
        count ++;
      }
    }
    console.log(count);
    count = 0;
  }
  
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
process.stdin.resume();
process.stdin.setEncoding("utf-8");

function print(x) {
    console.log(x);
}

let inputString = "";
let currentLine = 0;

process.stdin.on("data", inputStdin => {
    inputString += inputStdin;
});
process.stdin.on("end", () => {
    inputString = inputString.split("\n");
    main();
});
function readline() {
    return inputString[currentLine++];
}

//-----------main fucntion-----------

function main() {
    var input = parseInt(readline())
    var a = readline().split(" ").map(x => parseInt(x))
    var n = []
    n.push(input - 1)
    n.length = input
    n.fill(0, 1)
    print(n.join('\n'))
}
//  [go]
package main

import (
	"bufio"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func scanInt() int {
	sc.Scan()
	iv, _ := strconv.Atoi(sc.Text())
	return iv
}

func init() {
	sc.Split(bufio.ScanWords)
}

func main() {
	n := scanInt()
	xs := make([]int, n+1)
	for i := 1; i < n; i++ {
		a := scanInt()
		xs[a]++
	}

	var wr = bufio.NewWriter(os.Stdout)
	for i := 1; i <= n; i++ {
		wr.WriteString(strconv.Itoa(xs[i]) + "\n")
	}
	wr.Flush()
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	var n int
	fmt.Scan(&n)
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	v := make([]int, n)
	var a int
	for i := 1; i < n; i++ {
		sc.Scan()
		a, _ = strconv.Atoi(sc.Text())
		v[a-1]++
	}
	w := bufio.NewWriter(os.Stdout)
	for _, e := range v {
		fmt.Fprintln(w, e)
	}
	w.Flush()
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	initialBufSize = 1024
	maxBufSize     = 1e6
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	writer  = bufio.NewWriterSize(os.Stdout, 1000000)
)

func main() {
	scanner.Split(bufio.ScanWords)
	// scanner.Buffer(make([]byte, initialBufSize), maxBufSize)
	defer writer.Flush()
	n := scanInt()
	m := make([]int, n)
	for i := 0; i < (n - 1); i++ {
		m[scanInt()-1]++
	}

	for i := 0; i < n; i++ {
		fmt.Fprintf(writer, "%v\n", m[i])
	}
}

func scanInt() int {
	i, _ := strconv.Atoi(scanString())
	return i
}

func scanInts(size int) []int {
	ints := make([]int, size)
	for i := 0; i < size; i++ {
		ints[i] = scanInt()
	}
	return ints
}

func scanFloat64() float64 {
	f, _ := strconv.ParseFloat(scanString(), 64)
	return f
}

func scanFloat64s(size int) []float64 {
	f := make([]float64, size)
	for i := 0; i < size; i++ {
		f[i] = scanFloat64()
	}
	return f
}

func scanString() string {
	scanner.Scan()
	return scanner.Text()
}

func scanStrings(size int) []string {
	s := make([]string, size)
	for i := 0; i < size; i++ {
		s[i] = scanString()
	}
	return s
}
//  [go]
package main

import "fmt"

func main() {
	var N int
	fmt.Scanf("%d", &N)

	A := make([]int, N-1)
	for i := 0; i < N-1; i++ {
		fmt.Scanf("%d", &A[i])
	}
	for i := 1; i <= N; i++ {
		count := 0
		for j := 0; j < N-1; j++ {
			if i == A[j] {
				count++
			}
		}
		fmt.Println(count)
	}
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	nums := make([]int, n)
	for l:=0; l<n-1; l++{
		fmt.Scan(&nums[l])
	}

	count_map := make(map[int]int)

	for i:=1; i<=n; i++{
		for m:=0; m<n-1; m++{
			if i == nums[m]{
				count_map[i] ++
			}
		}
		fmt.Println(count_map[i])
	}

}
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	ma := make(map[int]int, n)
	for i := 2; i < n+1; i++ {
		var temp int
		fmt.Scan(&temp)
		ma[temp-1]++
	}

	for i := 0; i < n; i++ {
		if i < len(ma) {
			fmt.Println(ma[i])
		} else {
			fmt.Println(0)
		}
	}
}
//  [ruby]
n = gets.to_s.to_i
a = gets.to_s.split.map{|i| i.to_i }

ans = [0] * (n + 1)

a.each{|t| ans[t] += 1 }
ans.shift

p *ans
//  [ruby]
N = gets.to_i
A = gets.split.map &:to_i

ans = [0] * (N + 1)

A.each{|a|
  ans[a] += 1
}
ans.shift
p *ans
//  [ruby]
N = gets.to_i
A = gets.chomp.split(" ").map(&:to_i)

ans = Array.new(N+1, 0)
A.each{|a| ans[a] += 1}

ans.shift
puts ans * "\n"
//  [ruby]
N = gets.to_i
ary = gets.strip.split(nil).map(&:to_i)
png = []
i = 1
while i <= N do
  png[i-1] = ary.count(i)
  i += 1
end
puts png
//  [ruby]
n = gets.to_i
array = gets.split(" ").map(&:to_i)

(1..n).each do |n|
  puts array.count(n)
end
//  [ruby]
n = gets.chomp.to_i
a = gets.chomp.split(' ').map(&:to_i)
 
ans = Array.new(n){0}
a.each do |i|
  ans[a[i]-1] += 1
end
ans.each do |i|
  puts i
end
//  [rust]
use proconio::{fastout, input};

use proconio::marker::Usize1;

#[fastout]
fn main() {
    input! {
        n: usize,
        a: [Usize1; n - 1]
    }
    let mut b = vec![0; n];
    for x in a.iter() {
        b[*x] += 1;
    }
    for i in 0..n {
        println!("{}", b[i]);
    }
}
//  [rust]
use itertools::Itertools;
fn main() {
    proconio::input! {
        n: usize,
        a: [i64; n-1],
    }
    let mut v = vec![0; n];
    for a in a {
        v[(a - 1) as usize] += 1;
    }
    let ans = v.iter().join("\n");
    println!("{}", ans);
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: i64,
        a: [i64; n-1],
    }
    for _i in 1..a.len() + 2 {
        println!("{:?}", a.iter().filter(|&n| *n == _i as i64).count())
    }
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: i64,
        a: [i64; n-1],
    }
    for _i in 1..a.len() +2 {
        println!("{:?}", a.iter().filter(|&n| *n == _i as i64).count())
    }
}
//  [rust]
use proconio::input;
fn main(){
    input!{
        n: usize,
        a: [usize; n - 1]
    }
    let mut ans = vec![0; n + 1];
    for b in a {
        ans[b-1] += 1;
    }
    for i in 1 .. n {
        println!("{}", ans[i])
    }
}
//  [swift]
import Foundation
let main: () = {
    let N = nextInt()
    var A = listOfInt(-1)
    var ans = Array(N) { 0 }
    A.forEach { ans[$0] += 1 }
    print(ans.joinToString("\n"))
}()
@inlinable func next() -> String { readLine()! }
@inlinable func nextInt() -> Int { Int(next())! }
@inlinable func nextDouble() -> Double { Double(next())! }
@inlinable func listOfString() -> [String] { next().split(separator: " ").map(String.init) }
@inlinable func listOfInt(_ offset: Int = 0) -> [Int] { listOfString().map { Int($0)! + offset } }
extension Array {
    init(_ size: Int, _ initValue: (() -> Element)) {
        self = [Element]()
        for _ in 0 ..< size {
            let value = initValue()
            self.append(value)
        }
    }
}
extension Array where Element == Int {
    @inlinable func joinToString(_ sepatator: String = " ") -> String { self.map { String($0) }.joined(separator: sepatator) }
}
//  [swift]
protocol InitFromString {
    init?(_ str: String)
}

extension Int: InitFromString {}
extension Int8: InitFromString {}
extension Int16: InitFromString {}
extension Int32: InitFromString {}
extension Int64: InitFromString {}
extension String: InitFromString {}

func input<T: InitFromString>() -> [T] {
    readLine()!.split(separator: " ").map(String.init).compactMap(T.init)
}

let n: Int = input()[0]
let a: [Int] = input()

var res = [Int](repeating: 0, count: n)
a.forEach { (i) in
    res[i - 1] += 1
}

print(res.map(String.init).joined(separator: "\n"))
//  [swift]
let n = Int(readLine()!)!

let a = readLine()!.split(separator: " ").map {
  Int($0)!
}

var array: [Int] = Array(repeating: 0, count: n)

for member in a {
  array[member-1] += 1
}

print(array.map { String($0) }.joined(separator: "\n"))
//  [swift]
import Foundation

func readInts() -> [Int]{
    readLine()!.split(separator: " ").map { Int($0)! }
}

func main(){
    let n = Int(readLine()!)!
    let aryA = readInts()
//    TLE発生
//    for i in 1...n {
//        print(aryA.filter { $0 == i }.count > 0 ? aryA.filter { $0 == i }.count: 0)
//    }
//    修正後
    var counter = [Int](repeating: 0, count: n)
    print(counter)
    for i in aryA {
        counter[i-1] += 1
    }
    for i in 0...aryA.count{
        print(counter[i])
    }
}
main()
//  [swift]
import Foundation

func readInts() -> [Int]{
    readLine()!.split(separator: " ").map { Int($0)! }
}

func main(){
    let n = Int(readLine()!)!
    let aryA = readInts()
    for i in 1...n {
        print(aryA.filter { $0 == i }.count > 0 ? aryA.filter { $0 == i }.count: 0)
    }
}
main()
//  [typescript]
import { count } from 'console';

process.stdin.resume();
process.stdin.setEncoding('utf8');

// 標準入力取込
let gInput = '';
process.stdin.on('data', (chunk) => (gInput += chunk));
process.stdin.on('end', () => main(gInput.split(/\r?\n/)));

// 解答
function main(inputs: string[]): void {
  const num = Number(inputs[0].split(' ')[0]);
  const bossNum = inputs[1].split(' ').map(Number);
  const ans = new Array(num).fill(0);

  bossNum.forEach((value) => ans[value - 1]++);

  console.log(ans.join('\n'));
}
//  [typescript]
function Main(input) {
    const [N, As] = input.split("\n")
    const A = As.split(" ")
    const ans = new Array(Number(N)).fill().map(_ => 0);
    // 計算量削減のためarray.prototype.reduceではなくforを使う
    for (let i=0; i < A.length; i++) {
        ans[Number(A[i]-1)]++
    }
    console.log(ans.join("\n"))

}
// Main(`5
// 1 1 2 2`)
Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [typescript]
function Main(input) {
    const [N, As] = input.split("\n")
    const A = As.split(" ")
    const ans = new Array(N).map(e => 0);
    for (let i=0; i < A.length; i++) {
        ans[A[i]]++
    }
    console.log(ans.join("\n"))

}
// Main()
Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [typescript]
import * as fs from 'fs';

// parameter "input" gets all data
function Main(input: string) {
    const lines = input.split('\n');
    const n = parseInt(lines[0]);
    const a = [0, ...lines[1].split(' ').map(int => parseInt(int))];

    // console.log(n, a);
    let subordinates = [0];
    for (let i = 1; i < n; i++) {
        subordinates[i] = 0;
        for (let j = i; j < n; j++) {
            if (a[j] === i) {
                subordinates[i]++;
            }
        }
    }

    //output


    let result = [...subordinates.slice(1), 0];
    console.log(result);
    return result.join('\n');
}

// Don't edit this line!
Main(fs.readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [n]: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    const a: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    const map = {};
    for (let i = 1; i < n; i++) {
      const ai = a[i];
      if (!map[ai]) {
        map[ai] = 0;
      }
      map[ai]++;
    }
    for (let i = 1; i <= n; i++) {
      console.log(map[i] ? map[i] : 0);
    }
  }
}
Main.main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
a = int(input())
if a == 22:
	print("Christmas Eve Eve Eve")
elif a == 23:
	print("Christmas Eve Eve")
elif a == 24:
	print("Christmas Eve")
elif a == 25:
	print("Christmas")
//  [python]
x = int(input())
if x == 22:
  print("Christmas Eve Eve Eve")
elif x == 23:
  print("Christmas Eve Eve")
elif x == 24:
  print("Christmas Eve")
elif x == 25:
  print("Christmas")
//  [python]
N= input()
 
if(N == "25") : 
	print('Christmas')
if(N == "24") : 
	print("Christmas Eve")
if(N == "23") : 
	print("Christmas Eve Eve")
if(N == "22") : 
	print("Christmas Eve Eve Eve")
//  [python]
d = int(input())
if d = 25:
  print("Christmas")
elif d = 24:
  print("Christmas Eve")
elif d = 23:
  print("Christmas Eve Eve")
else:
  print("Christmas Eve Eve Eve")
//  [python]
x = int(input())
print("christmas"+" Eve"*(25-x))
//  [python]
x = int(input())
print("christmas"+"Eve"*(25-x))
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int d = Integer.parseInt(br.readLine());
        System.out.println(problem115a(d));
    }

    private static String problem115a(int d) {
        StringBuilder sb = new StringBuilder("Christmas");
        for (int i = 0; i < (25 - d); i++) {
            sb.append(" Eve");
        }
        return sb.toString();
    }
}
//  [java]
import static java.lang.Integer.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	public static int D;


	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
		st = new StringTokenizer(br.readLine());
		D = parseInt(st.nextToken());

		int x = 25;
		System.out.print("Christmas");
		for(int i=x;i>D;i--) {
			System.out.print(" Eve");
		}
		System.out.println();

	}

}
//  [java]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner();
		int d = sc.nextInt();
		String s = "Christmas";
		
		for(int i = d; i < 25; i++)
			s += " Eve";
		
		System.out.println(s);
	}
}

class Scanner {
	private static final int SPACE = (int)' ';
	private static final int LINE_END_0 = 13;
	private static final int LINE_END_1 = 10;
	private static final int BEFORE = -1;
	private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	
	public String next(){
		StringBuilder sb = new StringBuilder();
		
		int length = BEFORE;
		readLoop: while(true) {
			try {
				int value = br.read();
				switch(value) {
				case LINE_END_1:
					if(length == BEFORE)
						break;
					
					if((int)sb.charAt(length) == LINE_END_0)
						sb.deleteCharAt(length);
				case SPACE:
					break readLoop;
				}
				sb.append((char)value);
				length++;

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return sb.toString();
	}
	
	public String[] nextArray(int length) {
		String[] array = new String[length];
		for(int i = 0; i < length; i++)
			array[i] = next();
		return array;
	}
	
	public double nextDouble() {
		return Double.parseDouble(next());
	}
	
	public double[] nextDoubleArray(int length) {
		double[] array = new double[length];
		for(int i = 0; i < length; i++)
			array[i] = nextDouble();
		return array;
	}
	
	public int nextInt() {
		return Integer.parseInt(next());
	}
	
	public int[] nextIntArray(int length) {
		int[] array = new int[length];
		for(int i = 0; i < length; i++)
			array[i] = nextInt();
		return array;
	}
	
	public long nextLong() {
		return Long.parseLong(next());
	}
	
	public long[] nextLongArray(int length) {
		long[] array = new long[length];
		for(int i = 0; i < length; i++)
			array[i] = nextLong();
		return array;
	}
	
	public boolean ready() {
		try {
			return br.ready();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return false;
	}
}
//  [java]
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
    public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter ou = new PrintWriter(System.out);
		int n = 25 - Integer.parseInt(sc.next());
		ou.print("Christams");
		for(int i = 0 ; i < n ; i++) ou.print(" Eve");
		ou.println();
		ou.flush();
	}
}
//  [java]
import java.util.*;

public class Main {
	public static void main(String args[]) {
    	Scanner sc = new Scanner(System.in);
      
        int d = sc.nextInt();
        if (d == 25) {
            System.out.println("Christmas");
        } else if (d == 24) {
        	System.out.println("Christmas Eve");
        } else if (d == 23) {
            System.out.println("Christmas Eve Eve");
        } else if (d == 22) {
        	System.out.println("Christmas Eve Eve");
        }
    }
}
//  [java]
import java.util.*;

public class Main {
	public static void main(String args[]) {
    	Scanner sc = new Scanner(System.in);
      
        String d = sc.next();
        if (d.equals("Christmas")) {
            System.out.println(25);
        } else if (d.equals("Christmas Eve")) {
        	System.out.println(24);
        } else if (d.equals("Christmas Eve Eve")) {
            System.out.println(23);
        } else if (d.equals("Christmas Eve Eve Eve")) {
        	System.out.println(22);
        }
    }
}
//  [cpp]
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int main()
{
	int d;scanf("%d",&d);
	if(d==22) printf("Christmas Eve Eve Eve");
	else if(d==23) printf("Christmas Eve Eve");
	else if(d==24) printf("Christmas Eve");
	else if(d==25) printf("Christmas");
	return 0;
}
//  [cpp]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
	int n, N, i, j;

	scanf("%d", &n);
	if(n == 25)
		printf("Christmas\n");
	else if(n == 24)
		printf("Christmas Eve\n");
	else if(n == 23)
		printf("Christmas Eve Eve\n");
	else if(n == 22)
		printf("Christmas Eve Eve Eve\n");

	return 0;
}
//  [cpp]
#include<stdio.h>
int main(void) {
	int d,i;
	scanf("%d",&d);
	printf("Christmas");
	for (i = d; i < 25; i++) {
		printf(" Eve");
	}
	puts("");
	return 0;
}
//  [cpp]
/*
  Contest 115
  A - Christmas Eve Eve Eve
  Rakesh Kumar --> 28/09/2020
 */

#include <bits/stdc++.h>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0); std::cout.tie(0);

    int d = 0;
    std::string s = "Christmas ";
    for (int i = 0; i < 25 - d; ++i)
        s += "Eve ";
    std::cout << s.substr(0, s.size() - 1) << std::endl;

    return 0;
}
//  [cpp]
/*
  Contest 115
  A - Christmas Eve Eve Eve
  Rakesh Kumar --> 28/09/2020
 */

#include <bits/stdc++.h>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0); std::cout.tie(0);

    int d = 0;
    std::cout << "Christmas ";
    for (int i = 0; i < 25 - d; ++i)
        std::cout << "Eve ";
    std::cout << std::endl;

    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <math.h>
#include <sstream>
#include <iterator>

using namespace std;

#define endl ("\n")
#define pi (3.141592653589)
#define mod 1000000007
#define int int64_t
#define float double
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) c.begin(), c.end()
#define min3(a, b, c) min(c, min(a, b))
#define min4(a, b, c, d) min(d, min(c, min(a, b)))
#define rrep(i, n) for(int i=n-1;i>=0;i--)
#define rep(i,n) for(int i=0;i<n;i++)
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

struct debugger
{
    template<typename T> debugger& operator , (const T& v)
    {    
        cerr<<v<<" ";    
        return *this;    
    }
} dbg;

int32_t main() 
{
    fast;
	int D;
	cin >> D;
	if (D==25) cout << "Christmas";
	else if(D==24) cout << "Christmas Eve";
	else if(D==23) cout << "Christmas Eve Eve";
	else cout << "Christmas Eve Eve Ev