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()


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'));
}


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());


import * as fs from 'fs';

// main
function main(input: string[]) {
    // param
    var n: number = 0;
    var an: number[] = [];
    var ans: string = "";
    // init
    n = Number(input.shift());
    an = input.shift().split(" ").map(x => Number(x));
    an.unshift(0);
    an.unshift(0);
    // solve
    var w = new Array(n + 1).fill(0);
    for (var nx = 1; nx <= n; nx++) {
        w[an[nx]]++;
    }
    w.shift();
    ans = w.join("\n").trim();
    // answer
    console.log(ans);
}

// graph lib
/*
function GRAPH_enumPattern(cur: number[], pat: number[][]): number[][] {
    var arr = [];
    for (var patx = 0; patx < pat.length; patx++) {
        var pos = [cur[0] + pat[patx][0], cur[1] + pat[patx][1]];
        arr.push(pos);
    }
    return arr;
}
*/

// math lib
/*
function Math_max(arr: number[]): number { return arr.reduce((x, y) => Math.max(x, y)); }
function Math_min(arr: number[]): number { return arr.reduce((x, y) => Math.min(x, y)); }
function Math_gcd(): number {
    var ans = arguments[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < arguments.length; i++) {
        ans = f(ans, arguments[i]);
    }
    return ans
};
function Math_gcdArray(values: number[]): number {
    var ans = values[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < values.length; i++) {
        ans = f(ans, values[i]);
    }
    return ans
};
function Math_lcm(): number {
    var a = arguments
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_lcmArray(values: number[]): number {
    var a = values
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_primeList(value: number): number[] {
    var ans = [];
    var arr = new Array(value).fill(0);
    for (var i = 2; i < value; i++) {
        if (arr[i] == 0) {
            for (var j = i; j < value; j += i) {
                if (arr[j] == 0) arr[j] = i;
            }
        }
    }
    for (var i = 2; i < value; i++) {
        if (arr[i] == i) ans.push(i);
    }
    return ans;
}
function Math_primeFactor(p: number[], value: number): number[][] {
    var ans: number[][] = [];
    var valmax = value / 2;;
    for (var i = 0; i < p.length; i++) {
        var prime = p[i];
        if (valmax < prime) break;
        var count = 0;
        while (value % prime == 0) {
            value /= prime;
            count++;
        }
        if (count != 0) {
            ans.push([prime, count]);
        }
        if (value == 1) break;
    }
    return ans;
}
*/

// union-find lib
/*
var g_uf_root: number[];
var g_uf_count: number[];
function UF_initRoot(num: number) {
    g_uf_root = new Array(num).fill(-1);
    g_uf_count = new Array(num).fill(1);
}
function UF_getRoot(index: number) {
    if (g_uf_root[index] < 0) {
        return index;
    } else {
        var work0: number = UF_getRoot(g_uf_root[index]);
        g_uf_root[index] = work0;
        return work0
    }
}
function UF_mergeRoot(a: number, b: number) {
    var root0: number = UF_getRoot(a);
    var root1: number = UF_getRoot(b);
    if (root0 == root1) return;
    if (root0 > root1) [root0, root1] = [root1, root0];
    g_uf_count[root0] += g_uf_count[root1];
    g_uf_count[root1] = 0;
    g_uf_root[root1] = root0;
}
*/

// entrypoint
function entrypoint() {
    try {
        // linux
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            main(input);
        });
    }
}
entrypoint();


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());


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'));


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"));


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")


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")


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")


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")


x = int(input())
print("christmas"+" Eve"*(25-x))


x = int(input())
print("christmas"+"Eve"*(25-x))


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();
    }
}


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();

	}

}


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;
	}
}


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();
	}
}


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");
        }
    }
}


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);
        }
    }
}


#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;
}


#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;
}


#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;
}


/*
  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;
}


/*
  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;
}


#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


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
#include <string.h>
#define ll long long int

int main()
{
   int D;

   scanf("%d",&D);

   if (D==25)printf("Christmas");
   else if (D==24)printf("Christmas Eve");
   else if (D==23)printf("Christmas Eve Eve");
   else if (D==22)printf("Christmas Eve Eve Eve");

    return 0;
}


#include <stdio.h>
int main(void){
    int a;
    scanf("%d", &a);
    if(a==22)
        printf("Christmas Eve Eve Eve\n");
    if(a==23)
        printf("Christmas Eve Eve\n");
    if(a==24)
        printf("Christmas Eve\n");
    if(a==25)
        printf("Christmas\n");
    return 0;
}


#include <stdio.h>

int main(int argc, const char * argv[]) {
    int D;

    scanf("%d",&D);
    if (D<22 || D>25) {
        printf("22<=D<=25 の範囲で入力して下さい\n");
    } else {
        switch (D) {
            case 22:
                printf("Christmas Eve Eve Eve\n");
                break;
            case 23:
                printf("Christmas Eve Eve\n");
                break;
            case 24:
                printf("Christmas Eve\n");
                break;
            case 25:
                printf("Christmas\n");
                break;

            default:
                break;
        }

    }

    return 0;
}


#include<stdio.h>

int main(void){
    int d;

    scanf("%d", &d);
    switch(d){
        case 25:
            printf("Christmas\n");
            break;
        case 24:
            printf("Christmas Eve\n");
            break;
        case 23:
            printf("Christmas Eve Eve\n");
            break;
        case22:
            printf("Christmas Eve Eve Eve\n");
            break;
    }
    return 0;
}


#include<stdio.h>
int main(void)
{
	int D;
	scanf("%d",&D);
	if(D==25){
		printf("Chrismas\n");
	}
	if(D==24){
		printf("Chrismas Eve\n");
	}
	if(D==23){
		printf("Chrismas Eve Eve\n");
	}
	if(D==22){
		printf("Chrismas Eve Eve Eve\n");
	}
	return 0;
}


#include <stdio.h>

int main(void)
{
        int d;
        scanf("%d",&d);
        if(d==25)printf("Chrismas\n");
        else if(d==24)printf("Chrismas Eve\n");
        else if(d==23)printf("Chrismas Eve Eve\n");
        else printf("Chrismas Eve Eve Eve\n");
        return 0;
}


function main(input){
    d=input;
    var a=["Christmas","Christmas Eve","Christmas Eve Eve","Christmas Eve Eve Eve"];
    var b=[25,24,23,22]
    for (var i = 0;i<4;i++){
        if (d==b[i]){
            console.log(a[i])
        }
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input) {
  var D = Number(input.trim());
  var message = 'Christmas';
  for (var i = 25; D < i; i --) {
    message += ' Eve';
  }
  console.log(message);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input) {
  const D = parseInt(input, 10);
  if(D==25){
    console.log("Christmas");
  }else if(D==24){
    console.log("Christmas Eve");
  }else if(D==23){
    console.log("Christmas Eve Eve");
  }else if(D==22){
    console.log("Christmas Eve Eve Eve");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


'use strict';

function main(arg) {
  const input = arg.trim().split('\n');
  const d = Number(input[0]);
  const diff = 25 - d;
  let ans = 'Christmas';
  ans = ans + ' Eve' * diff;
  console.log(ans);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


"use strict";
process.stdin.resume();
process.stdin.setEncoding("utf-8");

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

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

// ************************ Code Start ***************************

function main() {

  t = Number(readline());
  if (t == 25) print("Christmas");
  else if (t == 24) print("Christmas Eve");
  else if (t == 23) print("Christmas Eve Eve");
  else print("Christmas Eve Eve Eve");
}


function main(D){
    if(D=="22"){
        console.log("Christmas Eve Eve Eve");
    } else if (D=="23"){
        console.log("Christmas Eve Eve");
    } else if (D=="24"){
        console.log("Christmas Eve");
    } else if (D=="25"){
        console.log("Christmas");
    }
}
main(require('fs').readFileSync('/dev/stdin','utf8'));


package main

import (
	"fmt"
)

func main() {
	var d int
	fmt.Scan(&d)

	var e string
	for i := 0; i < 25-d; i++ {
		e += " Eve"
	}
	fmt.Println("Christmas" + e)
}


package main

import (
  "fmt"
  "strings"
)

func main() {
  var d int
  fmt.Scan(&d)
  ans := "Christmas"
  tail := " Eve"
  ans += strings.Repeat(tail, 25 - d)
  fmt.Println(ans)
}


package main

import "fmt"

func main() {
	var d int
	fmt.Scan(&d)

	if d == 25 {
		fmt.Println("Christmas")
	} else if d == 24 {
		fmt.Println("Christmas Eve")
	} else if d == 23 {
		fmt.Println("Christmas Eve Eve")
	} else {
		fmt.Println("Christmas Eve Eve Eve")
	}
}


package main

import(
    "fmt"
    "sort"
    "strings"
)

func main() {
    var a int
    fmt.Scan(&a)
    ans := "Christmas"
    for i:=0; i<25-d; i++{
        ans += " Eve"
    }
    fmt.Println(ans)
}

func abs32(a int) int {
    if a<0{
        return -a
    }
    return a
}

func abs64(a int64) int64 {
    if a<0{
        return -a
    }
    return a
}

func min32(a, b int) int {
    if a >= b {
        return b
    }
    return a
}

func max32(a, b int) int {
    if a >= b {
        return a
    }
    return b
}

func min64(a, b int64) int64 {
    if a >= b {
        return b
    }
    return a
}

func max64(a, b int64) int64 {
    if a >= b {
        return a
    }
    return b
}

func gcd(a, b int64) int64 {
    if a % b == 0 {
        return b
    } else {
        return gcd(b, a%b)
    }
}

func lcm(a, b int64) int64 {
    return a / gcd(a, b) * b
}

func scanNums(len int) (nums []int){
    var num int
    for i:=0; i<len; i++{
        fmt.Scan(&num)
        nums = append(nums,num)
    }
    return
}

func scanNums64(len int) (nums []int64){
    var num int64
    for i:=0; i<len; i++{
        fmt.Scan(&num)
        nums = append(nums,num)
    }
    return
}

func scanString(len int) (str []string){
    var s string
    for i:=0; i<len; i++{
        fmt.Scan(&s)
        str = append(str,s)
    }
    return
}

func scanTwoNums(n,m int) ([][]int){
    Nums := make([][]int, n)
    for i:=0; i<n; i++{
        Nums[i] = make([]int, m)
    }
    return Nums
}

func SortString(s string) string{
    t := strings.Split(s, "")
    sort.Strings(t)
    return strings.Join(t, "")
}


package main

import "fmt"

func main(){
  var D int
  fmt.Scan(&D)
  var ans := "Christmas"

  for {
    if D == 25 {
      break
    }
    ans += " Eve"
    D++
  }
  fmt.Println(ans)
}


package main

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

func main() {
	switch 25 {
	case 22:
		fmt.Println("Christmas Eve Eve Eve")
	case 23:
		fmt.Println("Christmas Eve Eve")
	case 24:
		fmt.Println("Christmas Eve")
	case 25:
		fmt.Println("Christmas")
	}
}

// https://atcoder.jp/contests/abc125/submissions/5181045
func pow(a, b int) int {
	return int(math.Pow(float64(a), float64(b)))
}

func lcm(a, b int) int {
	return a * b / gcd(a, b)
}

func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func max(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r < a[i] {
			r = a[i]
		}
	}
	return r
}

func min(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r > a[i] {
			r = a[i]
		}
	}
	return r
}

func sum(a []int) (r int) {
	for i := range a {
		r += a[i]
	}
	return r
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

var nextReader func() []byte

func init() {
	nextReader = newScanner()
}

func newScanner() func() []byte {
	r := bufio.NewScanner(os.Stdin)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)
	return func() []byte {
		r.Scan()
		return r.Bytes()
	}
}

func nextBytes() []byte {
	return nextReader()
}

func nextString() string {
	return string(nextReader())
}

func nextInt64() int64 {
	v, _ := strconv.ParseInt(string(nextReader()), 10, 64)
	return v
}

func nextInt() int {
	v, _ := strconv.Atoi(string(nextReader()))
	return v
}

func nextInts(n int) []int {
	r := make([]int, n)
	for i := 0; i < n; i++ {
		r[i] = nextInt()
	}
	return r
}

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(string(nextReader()), 64)
	return f
}


d = gets.to_i
d -= 25

print 'Christmas'

while d < 0
  print ' Eve'
  d += 1
end

print "\n"


a = "Christmas"
d = gets.chomp.to_i.upto(24){a += " Eve"}
puts a


D=gets.to_i
s='Christmas'
(25-D).times{
	s+=' Eve'
}
puts s


d = gets.to_i
case d
when 25
  puts "Christmas"
when 24
  puts "Christmas Eve"
when 23
  puts "Christmas Eve Eve"
when 22
  puts "Christmas Eve Eve"
end


print "Christmas"
for i in 25-gets.to_i do
  print " Eve"
end
puts ""


puts"Christmas"+" Eve"*(103-`dd`.sum)


use std::io::*;
use std::str::FromStr;

//https://qiita.com/tubo28/items/e6076e9040da57368845
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
    let n:u32 = read();
    let ans = match n {
        22 => "Christmas Eve Eve Eve",
        23 => "Christmas Eve Eve",
        24 => "Christmas Eve",
        _ => "Christmas",
    };
    println!("{}",ans);
}


use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let d: i64 = read();
    println!(
        "{}",
        match d {
            22 => "Christmas Eve Eve Eve",
            23 => "Christmas Eve Eve",
            24 => "Christmas Eve",
            25 => "Christmas",
            _ => "",
        },
    )
}


#[allow(unused_imports)]
use std::char::*;
#[allow(unused_imports)]
use std::cmp::*;
use std::io::*;
use std::str::FromStr;
#[allow(unused_imports)]
use std::collections::*;

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[derive(PartialEq, PartialOrd)]
pub struct Total<T>(pub T);

impl<T: PartialEq> Eq for Total<T> {}

impl<T: PartialOrd> Ord for Total<T> {
    fn cmp(&self, other: &Total<T>) -> std::cmp::Ordering {
        self.0.partial_cmp(&other.0).unwrap()
    }
}

//const MAX:usize = 100006;
//const INF:u64 = u64::max_value();

fn main() {
    let d:u32 = read();

    let d = 25-d;
    let mut s = String::from("Christmas");
    for i in 0..d {
        s.push_str(" Eve");
    }

    println!("{}", s);

}


use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
  let stdin = stdin();
  let stdin = stdin.lock();
  let token: String = stdin
    .bytes()
    .map(|c| c.expect("failed to read char") as char)
    .skip_while(|c| c.is_whitespace())
    .take_while(|c| !c.is_whitespace())
    .collect();
  token.parse().ok().expect("failed to parse token")
}

pub fn read_n<T: FromStr>(n: usize) -> Vec<T> {
  read_n_logic::<T>(n, vec![])
}

pub fn read_n_logic<T: FromStr>(n: usize, mut a: Vec<T>) -> Vec<T> {
  match n {
    0 => a,
    _ => {
      a.push(read::<T>());
      read_n_logic(n - 1, a)
    }
  }
}

use std::cmp::{max, min};
use std::collections::BinaryHeap;
use std::collections::HashMap;

fn main() {
  let mut n: i64 = read();
  let mut x: i64 = read();
  let mut ans: i64 = 0;
  // ;ans
  let mut p = vec![0; 51];
  let mut t = vec![0; 51];
  p[1] = 3;
  t[1] = 5;
  for i in 2..51 {
    p[i] = p[i - 1] * 2 + 1;
    t[i] = t[i - 1] * 2 + 3;
  }

  while 0 < n {
    let atumi = t[n as usize - 1];
    let pathi = p[n as usize - 1];

    // println!(
    //   "atumi: {} pathi: {} ans: {} n: {} x: {}",
    //   atumi, pathi, ans, n, x
    // );

    if n == 1 {
      if x == 1 {
        ans += 0;
      } else if 1 < x && x <= 4 {
        ans += x - 1;
      } else {
        ans += 3
      }
      break;
    }

    if x == 1 {
      ans += 0;
      break;
    } else if x == atumi + 2 {
      ans = pathi + 1;
      break;
    } else if x == atumi * 2 + 3 {
      ans = pathi * 2 + 1;
      break;
    } else if 1 < x && x <= atumi + 1 {
      n -= 1;
      x -= 1;
    } else {
      n -= 1;
      x -= 2 + atumi;
      ans += pathi + 1;
    }
  }

  println!("{}", ans);
}


fn main() {
    input! { mut d: usize }
    let mut ret: String = "Christmas".to_string();
    while d < 25 {
        ret.push_str(" Eve");
        d += 1;
    }
    println!("{}", ret);
}


use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).ok().unwrap();
    let ans = match input.as_str() {
        "25" => "Christmas",
        "24" => "Christmas Eve",
        "23" => "Christmas Eve Eve",
        "22" => "Christmas Eve Eve Eve",
        _ => ""
    };
    println!("{}", ans);
}


//作成日：4/20

//日付を受け取る変数
var day = Int(readLine()!)!

//条件分岐
if (day == 25){
  print ("Christmas")
}
else if (day == 24){
  print ("Christmas Eve")
}
else if (day == 23){
  print ("Christmas Eve Eve")
}
else{
  print ("Christmas Eve Eve Eve")
}


let D = Int(readLine()!)!
print("Christmas" + String(repeating: " Eve", count: 25-D))


var tmp: String? = readLine()
var tmp2: String = tmp!
var d = Int(tmp2)!

var ans: String = "Christmas"
for _ in 0..<25-d{
    ans += " Eve"
}

print(ans)


var a = readLine()!
var c = Int(a)!
var b = readLine()!
var d = Int(b)!
print(6 - c - d)


import Foundation

let input_readLine = readLine()!

if Int(input_readLine)! == 25 {
  print("Christmas")
} else if Int(input_readLine)! == 24 {
  print("Christmas Eve")
} else if Int(input_readLine)! == 23 {
  print("Christmas Eve Eve")
} else {
  print("Christmas Eve Eve Eve")


import Foundation

for D in 22...25{
if D == 22 {
    print ("Christmas Eve Eve Eve")
}
else if D == 23{
    print ("Christmas Eve Eve")
}
else if D == 24 {
    print ("Christmas Eve")
}
else if D == 25 {
    print ("Christmas")
}
}


import * as fs from 'fs';

namespace AtCoder.abc115 {

    class Program {
        /**
         * in
         *  25
         * out
         *  Christmas
         */
        main(inp:string) {
            const days :any= {
                '22': 'Christmas Eve Eve Eve',
                '23': 'Christmas Eve Eve',
                '24': 'Christmas Eve',
                '25': 'Christmas',
            };
            console.log(days[inp]);
        }
    }

    const prg = new Program();
    prg.main(fs.readFileSync('/dev/stdin', 'utf8').trim());
}


var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var parts = input.split(" ");
var D = parseInt(parts[0]);
switch (D) {
    case 25:
        console.log("Christmas");
        break;
    case 24:
        console.log("Christmas Eve");
        break;
    case 23:
        console.log("Christmas Eve Eve");
        break;
    case 22:
        console.log("Christmas Eve Eve Eve");
        break;
    default:
        break;
}


const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[])=>{for(let i=0;i<a.length;i+=2)if(s==a[i])return a[i+1]};
const main = ()=>{
  out(sw(nin(),[
    25,'Christmas',
    24,'Christmas Eve',
    23,'Christmas Eve Eve',
    22,'Christmas Eve Eve Eve',
  ]));
}
main();


function main(input:string) {
    const i = input.split("\n");
    const n =  parseInt(i[0].split(" ")[0]);
    const k = parseInt(i[0].split(" ")[1]);
    let answer = [];

    const h = i.slice(1,n+1).map(x => parseInt(x)).sort((a,b) => { return a-b });

    for (let j = 0; j < n - k + 1; j++) {
        answer.push(h[k - 1 + j] - h[j]);
    }
    console.log(answer.reduce((a,b)=>Math.min(a,b)));

}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


a, b, c  = map(int, input().split())
if a <= c <= b:
    print('Yes')
else:
    print('No')


A,B,C=map(int, input().split())
if C>=A and C<=B:
  print("Yes")
else:
  print("No")


def main():
    A, B, C = map(int, input().split())

    if A <= C <= B:
        print('Yes')
    else:
        print('No')

main()


A,B,C = map(int, input().split())

if C > A and C < B:
    print('Yes')
else:
    print('No')


a,b,c = map(int,input().split())

if a<=b and b<=c:
    print('Yes')
else:
    print('No')


A, B, C = map(int, input().split())
print("YES" if C >= A and C <= B else "No")


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));
		String str1=br.readLine();
		String[] str2 = str1.split(" ", 0);

		int n1=Integer.parseInt(str2[0]);
		int n2=Integer.parseInt(str2[1]);
		int n3=Integer.parseInt(str2[2]);

		if(n1<=n3&&n3<=n2){
			System.out.println("Yes");
		}
		else{
			System.out.println("No");
		}
	}
	}


import java.io.*;

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    String[] data = br.readLine().split(" ");
    int a = Integer.parseInt(data[0]);
    int b = Integer.parseInt(data[1]);
    int c = Integer.parseInt(data[2]);

    if (c >= a && c<= b){
      System.out.println("Yes");
    } else {
      System.out.println("No");
    }
  }
}


import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		int A = sc.nextInt();
		int B = sc.nextInt();
		int C = sc.nextInt();

		if (A <= C && C <= B) {
			System.out.println("Yes");
		} else {
			System.out.println("No");
		}
	}

	private static boolean isDebug = System.getProperty("sun.desktop") != null;

	private static void debug(Object... o) {
		if (isDebug) {
			System.err.println(Arrays.deepToString(o));
		}
	}

	public static class Scanner {
		private BufferedInputStream inputStream;

		public Scanner(InputStream in) {
			inputStream = new BufferedInputStream(in);
		}

		public int nextInt() throws IOException {
			int num = 0;
			int sign = 1;

			int read = skip();
			if (read == '-') {
				sign = -1;
				read = inputStream.read();
			}

			do {
				num = num * 10 + sign * (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(int[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b, int[] c) throws IOException {
			if (a.length != b.length || b.length != c.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
				c[i] = nextInt();
			}
		}

		public long nextLong() throws IOException {
			long num = 0;

			int read = skip();
			do {
				num = num * 10 + (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(long[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
			}
		}

		public void fill(long[] a, long[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
				b[i] = nextLong();
			}
		}

		public long[] nextLong(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++) {
				array[i] = nextLong();
			}

			return array;
		}

		public String next() throws IOException {
			StringBuilder builder = new StringBuilder();

			int read = skip();
			do {
				builder.append((char) read);
			} while ((read = inputStream.read()) > 0x20);

			return builder.toString();
		}

		private int skip() throws IOException {
			int read;
			while ((read = inputStream.read()) <= 0x20)
				;

			return read;
		}
	}
}


import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();

      if(c>=a && a<=b){
      	System.out.println("Yes");
      }else{
      	System.out.println("No");
      }

	}
}


import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();

      if(c>=a && a<=b){
      	System.out.println('Yes');
      }else{
      	System.out.println('No');
      }

	}
}


import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			int n = scanner.nextInt(), m = scanner.nextInt();
			Path[] paths = new Path[m];
			IntStream.range(0, m).forEach(
					// 最長距離を計算するため、距離をマイナスにする
					i -> paths[i] = new Path(scanner.nextInt() - 1, scanner.nextInt() - 1, -scanner.nextLong()));
			long[] distances = new long[n];
			if (bellmanFord(paths, 0, n, distances)) {
				System.out.println("inf");
			} else {
				System.out.println(-distances[n - 1]);
			}
		}
	}

	/**
	 * https://www.geeksforgeeks.org/bellman-ford-algorithm-dp-23/ を参考に作成
	 *
	 * @param paths     ノード間の連結パス一覧の配列
	 * @param src       開始ノード
	 * @param n         ノードの数
	 * @param distances 開始ノードから各ノードへの最短距離の配列
	 * @return グラフにはループが含まれているかどうか
	 */
	private static boolean bellmanFord(final Path[] paths, final int src, final int n, final long[] distances) {
		Arrays.fill(distances, Long.MAX_VALUE);
		distances[src] = 0;

		IntStream.range(1, n).forEach(i -> IntStream.range(0, paths.length).forEach(j -> {
			int from = paths[j].from, to = paths[j].to;
			long cost = paths[j].cost;
			if (distances[from] != Long.MAX_VALUE && distances[from] + cost < distances[to]) {
				distances[to] = distances[from] + cost;
			}
		}));

		// マイナスのループが含まれているかどうかを判定
		// 解説に参考して作成
		boolean[] negative = new boolean[n];
		Arrays.fill(negative, false);
		IntStream.range(0, n).forEach(i -> IntStream.range(0, paths.length).forEach(j -> {
			int from = paths[j].from, to = paths[j].to;
			if (distances[from] != Long.MAX_VALUE && distances[from] + paths[j].cost < distances[to]) {
				distances[to] = distances[from] + paths[j].cost;
				negative[to] = true;
			}
			if (negative[from]) {
				negative[to] = true;
			}
		}));
		return negative[n - 1];
	}

	/**
	 * ノード間の一つのパスを表すクラス
	 */
	private static class Path implements Comparable<Path> {
		/** 開始ノード */
		int from;
		/** 終了ノード */
		int to;
		/** 移動コスト */
		long cost;

		Path(int from, int to, long cost) {
			super();
			this.from = from;
			this.to = to;
			this.cost = cost;
		}

		@Override
		public int compareTo(Path path) {
			long costDiff = this.cost - path.cost;
			return (costDiff > 0) ? 1 : (costDiff < 0) ? -1 : 0;
		}
	}
}


#include  <cstdio>
#include <cstdlib>

using namespace std;

int main(){
	int a,b,c;
	scanf("%d %d %d",&a,&b,&c);

	if(a<=c&&c<=b){
		printf("Yes\n");
	}else{
		printf("No\n");
	}

	return 0;
}


#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
using namespace std;
int a, b, c;
int main()
{
	scanf("%d%d%d", &a, &b, &c);
	if(b >= a && b >= c)printf("Yes\n");
	else printf("No\n");
}


#include <stdio.h>
#include <algorithm>

int main() {
	int A, B, C;
	scanf("%d %d %d", &A, &B, &C);
	if (A <= C && C <= B)
		printf("Yes\n");
	else
		printf("No\n");
}


#include <bits/stdc++.h>

#define ln "\n"
#define SORT(X) sort(X.begin(), X.end())
#define SORTi(X) sort(X.begin(), X.end(), greater<ll>())
#define REP(x, a, b) for (auto x = a; x <= b; x++)
#define REPi(x, b, a) for (auto x = b; x >= a; x--)
#define REPit(x, A) for (auto x = A.begin(); x != A.end(); x++)
#define REPr(x, A) for (auto x : A)
#define ll long long
#define ull unsigned long long
#define PB push_back
#define EB emplace_back
#define UMP unordered_map
#define UST unordered_set

using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int A, B, C;
    if (C >= A && C <= B)
        cout << "Yes" << ln;
    else
        cout << "No" << ln;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define txt                        \
    freopen("ip.txt", "r", stdin); \
    freopen("op.txt", "w", stdout)
#define a3 INT_MAX
#define i3 INT_MIN
#define a6 INT64_MAX
#define i6 INT64_MIN
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define fo(i, n) for (int i = 0; i < (int)n; i++)
#define rep(i, k, n) for (int i = k; k < (int)n ? i < (int)n : i > (int)n; k < (int)n ? i += 1 : i -= 1)
#define quickie                       \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
#define div2(a) (!(a & 1))
#define deb(x) cout << (#x) << " " << (x) << "\n";
#define newl cout << "\n"
#define all(s) s.begin(), s.end()
#define pi 3.14159265358979323846
#define fp(x) fixed << setprecision(x) <<
template <class T>
T mod(T a)
{
    if (a < 0)
    {
        a += 1000000007;
    }
    return a % 1000000007;
}
template <class T>
T addmod(T a, T b)
{
    return (mod(a) + mod(b)) % 1000000007;
}
template <class T>
T prodmod(T a, T b)
{
    return (mod(a) * mod(b)) % 1000000007;
}
template <class T>
T bin_exp(T a, T b)
{
    T res = 1;
    T temp = 1;
    if (b <= 1)
        return a;
    if (b % 2 == 0)
        res = bin_exp(a * a, b / 2);
    else
    {
        res *= a;
        temp = bin_exp(a, --b);
    }
    return res * temp;
}
template <class T>
T bin_expmod(T a, T b)
{
    T res = 1;
    T temp = 1;
    if (b <= 1)
        return a;
    if (b % 2 == 0)
        res = bin_expmod(prodmod(a, a), b / 2);
    else
    {
        res = prodmod(a, res);
        temp = bin_exp(a, --b);
    }
    return prodmod(res, temp);
}

template <class T>
int digit(T a)
{
    vector<long long> dig = {
        0,
        9,
        99,
        999,
        9999,
        99999,
        999999,
        9999999,
        99999999,
        999999999,
        9999999999,
        99999999999,
        999999999999,
        9999999999999,
        99999999999999,
        999999999999999,
        9999999999999999,
        99999999999999999,
        999999999999999999,
        INT64_MAX};
    auto it = lower_bound(dig.begin(), dig.end(), a);
    int idx = (it - dig.begin());
    return idx;
}
template <class T>
int sumAllInts(T n)
{
    int a = 1;
    int su = 0;
    while (n)
    {
        su += n % 10;
        n /= 10;
    }
    return su;
}
template <class T>
void split(char c, T s)
{
    int n = s.size();
    int i = 0;
    while ((cout << s[i], i += 1) && (i < n) && (cout << c << ' '))
        ;
}

void solve()
{
    vector<int> arr(51,0);
    int n,m; cin>>n>>m;
    fo(i,2*n){
        int temp;
        cin>>temp;
        arr[temp]++;
    }
    fo(i,n+1){
        if(arr[i]){
            cout<<arr[i];
            newl;
        }
    }
    return;
}
int main()
{
    quickie;
    //txt;
    int t = 1;
    while (t--)
    {
        solve();
        newl;
    }
    return 0;
}


#include <iostream>
using namespace std;

int main() {
 int a, b, c;
 cin >> a >> b >> c;
 if (a <= c && b >= c) {
   cout << "Yes";
 else {
   cout << "No";
 }
}


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i <= n; i++)
#define RREP(i, n) for (ll i = n - 1; i >= 0; i--)
#define RREP1(i, n) for (ll i = n; i >= 1; i--)
#define FOR(i, a, b, c) for (ll i = a; i <= b; i += c)
#define RFOR(i, a, b, c) for (ll i = a; i >= b; i -= c)
#define MAX(a, b) (a > b ? a : b)
#define MIN(a, b) (a < b ? a : b)
#define SORT(t, a, n) qsort(a, n, sizeof(t), ({ int _f (const void *_a, const void *_b) { return *(t *)_a - *(t *)_b; } _f; }))
#define RSORT(t, a, n) qsort(a, n, sizeof(t), ({ int _f (const void *_a, const void *_b) { return *(t *)_b - *(t *)_a; } _f; }))
#define SUM(a, n) ({ ll _s = 0; REP(_i, n) _s += a[_i]; _s; })
#define CNT(x, a, n) ({ ll _c = 0; REP(_i, n) if (a[_i] == x) _c++; _c; })
#define MAXM(t, a, n) ({ t _m = a[0]; REP(_i, n) _m = MAX(_m, a[_i]); _m; })
#define MINM(t, a, n) ({ t _m = a[0]; REP(_i, n) _m = MIN(_m, a[_i]); _m; })
#define INF 1145141919
typedef long long ll;

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);

    if (c >= a && c <= b) puts("Yes");
    else puts("No");
    return 0;
}


#include <stdio.h>
#include <string.h>

int main() {
	int a, b, c;
	scanf("%d%d%d", &a, &b, &c);
	if (c >= a && c <= b) printf("Yes\n");
	else printf("No\n");
	return 0;
}


#include<stdio.h>

int main(){
    int A,B,C;
    scanf("%d %d %d",&A,&B,&C);
    if(C>=A&&C<=B){
        printf("Yes\n");
    }else{
        printf("No\n");
    }
}


#include<stdio.h>
signed main(){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    if(a<=c<=b){
        printf("Yes\n");
    }else{
        printf("No\n");
    }
    return(0);
}


#include<stdio.h>
signed main(){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    if(a<c<=b){
        printf("Yes\n");
    }else{
        printf("No\n");
    }
    return(0);
}


#include <stdio.h>

int main(void) {
	// your code goes here
	int a,b,c;
	scanf("%d %d %d",&a,&b,&c);
	if(a <= c && b >= c){
		printf("yes");
	}
	else{
		printf("no");
	}
	return 0;
}


'use strict'

const main = input => {
	const args = input.trim().split(' ')
	const a = parseInt(args[0], 10)
	const b = parseInt(args[1], 10)
	const c = parseInt(args[2], 10)
	if (c >= a && c <= b) console.log('Yes')
	else console.log('No')
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))


function Main(input) {
	var A = parseInt(input.split(" ")[0]);
  var B = parseInt(input.split(" ")[1]);
  var C = parseInt(input.split(" ")[2]);
  if(A <= C && B >= C){
     console.log("Yes");
     }else{
     console.log("No");
     }

}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main (s) {
    s=s.split(" ");
	s[0]=parseInt(s[0]);
	s[1]=parseInt(s[1]);
	s[2]=parseInt(s[2]);
	console.log((s[2]>=s[0]&&s[2]<=s[1])?"Yes\n":"No\n");
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


// inputに入力データ全体が入る
function Main(input) {
  const hoge = input.split(' ');
  const A = hoge[0];
  const B = hoge[1];
  const C = hoge[2];

  if (C >= A && C <= B) {
    console.log('Yes');
  } else {
    console.log('No');
  }
}

// let input = `6 5 4`;
// Main(input);
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// inputに入力データ全体が入る
function Main(input) {
  const hoge = input.split(' ');
  const A = hoge[0];
  const B = hoge[1];
  const C = hoge[2];

  if (C >= A && C <= B) {
    console.log('Yes');
  } else {
    console.log('No');
  }
}

// let input = `1 3 2`;
// Main(input);
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input) {
  input = input.trim();
  const [a,b,c] = input.split(" ").map(Number);

  if(a>=c && b<=c){
    console.log("Yes");
  }else{
    console.log("No");
  }

}
main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scanf("%d %d %d", &a, &b, &c)
	if a <= c && c <= b {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


package main

import (
	"fmt"
)

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if c >= a && c <= b {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


package main

import (
	"fmt"
)

func main() {
	var a int
	var b int
	var c int
	fmt.Scan(&a, &b, &c)
	if c >= a && c <= b {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


package main

import (
	"fmt"
)

func main() {
	var (
		A, B, C int
	)

	fmt.Scan(&A, &B, &C)

	if C >= A && C <= B {
		fmt.Print("YES")
	} else {
		fmt.Print("NO")
	}
}


package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	if a <= c && c <= b {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()

	nums := make([]int, 0, 2)
	for _, str := range strings.Split(sc.Text(), " ") {
		n, _ := strconv.Atoi(str)
		nums = append(nums, n)
	}

	fmt.Println(nums)

	if nums[2] >= nums[0] && nums[2] <= nums[1] {
		fmt.Print("Yes")
	} else {
		fmt.Print("No")
	}
}


a,b,c = gets.chomp.split(' ').map(&:to_i)
if a <= c && b >= c
  puts "Yes"
else
  puts "No"
end


a,b,c=gets.split.map(&:to_i);puts c >= a && c < b || a == b ? "Yes" : "No"


A, B, C = gets.split.map{|i|i.to_i}
puts (A <= C && C <= B ? "Yes" : "No")


a, b, c = gets
if c >= a && c <= b
  puts 'YES'
else
  puts 'NO'


a,b,c=gets.split.map(&:to_i)
puts (a..b).include? c ? "Yes" : "No"


a,b,c = gets.chomp.split.map(&:to_i)
if [a,b,c].sort[1] == c
  puts "Yes"
else
  puts "No"
end


use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let a = v[0];
	let b = v[1];
	let c = v[2];
	if c >= a && c <= b {
		println!("Yes");
	}else{
		println!("No");
	}
}


#![allow(unused_imports)]
#![allow(dead_code)]
#![macro_use]
use std::io::prelude::*;
use std::cmp::{max, min};
use std::collections::BinaryHeap;

const MOD: i64 = 1e9 as i64 + 7;

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        a: isize,
        b: isize,
        c: isize,
    }
    println!("{}", if c >= a && c <= b {"Yes"} else {"No"});
}


use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

use std::cmp::max;

fn main() {
    let a: i64 = read();
    let b: i64 = read();
    let c: i64 = read();

    if c >= a && c <= b {
        println!("Yes")
    } else {
        println!("No")
    }
}


use proconio::input;

fn main() {

  let mut _a : i128 ;
  let mut _b : i128 ;
  let mut _c : i128 ;

    input! {

      mut a : i128,
      mut c : i128,
      mut b : i128,

    }
   if c >= a && c <= b {
     println!("Yes");
   }else{
    println!("No");

   }

}


use std::io::*;

fn main() {
    let mut s: String = String::new();
    std::io::stdin().read_to_string(&mut s).ok();
    let mut itr = s.trim().split_whitespace();

    let a: usize = itr.next().unwrap().parse().unwrap();
    let b: usize = itr.next().unwrap().parse().unwrap();
    let c: usize = itr.next().unwrap().parse().unwrap();
    println!("{}", if a <= c && c <= b { "Yes" } else { "No" });
}


let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[0]>i[2]||i[2]>i[1] ?"No":"Yes")


let array: [Int] = readLine()!.characters.split(" ").map { Int(String($0)) ?? 0 }
let ans: String = (array[2] >= array[0] && array[2] <= array[1]) : "Yes" ? "No"
print(ans)


import Foundation

let input_line: String = readLine()!
let array: [Int] = input_line.components(separatedBy: " ").compactMap { Int($0) ?? 0 }

let ans: String
if (array[2] >= array[0] && array[2] <= array[1]) {
    ans = "Yes"
} else {
    ans = "No"
}

print(ans)


let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[0]<i[2]&&i[2]<=i[1] ?"Yes":"No")


var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var A = parseInt(parts[0]);
var B = parseInt(parts[1]);
var C = parseInt(parts[2]);
var satisfy: boolean = C >= A && C <= B;
console.log(satisfy ? "Yes" : "No");


import * as fs from 'fs';

const [a, b, c]: number[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(Number);

if (a <= c && b >= c) {
    console.log('Yes');
} else {
    console.log('No');
}


const main = (input) => {
  input = input.split(' ');
  const a = parseInt(input[0]);
  const b = parseInt(input[1]);
  const c = parseInt(input[2]);

  if (a<=c&&c<=b) {
    console.log("Yes");
  }else{
    console.log("No");
  }

}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let[a,b,c]=srin(3)
  out(c>=a&&c<=b?'Yes':'No')
}
main()


const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};const yn=(a)=>{return a?'Yes':'No'};const YN=(a)=>{return a?'YES':'NO'};
const main = ()=>{
  let[a,b,c]=srin(3)
  out(yn(c>=a&&c<=b))
}
main()


const main = (input) => {
  input = input.split(' ');
  const a = parseInt(input[0]);
  const b = parseInt(input[1]);
  const c = parseInt(input[2]);

  if (a<=c<=b) {
    console.log("Yes");
  }else{
    console.log("No");
  }

}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


a = list(map(int, input().split()))
import math
def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
if a[0] <=1:
	b = 0
else:
	b = combinations_count(a[0], 2)
if a[1] <=1:
	c = 0
else:
	c = combinations_count(a[1], 2)
print(b + c)


def comb(a):
    if a < 2:
        return 0
    else:
        return a * (a-1) // 2

N, M = map(int, input().split())
print(comb(N)+comb(M))


n, m = map(int, input().split())
print( n * (n - 1) // 2 + m * (m - 1) // 2)


import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

N, M = na()
print(N * (N - 1) // 2 + M * (M - 1) * 2)


import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

N, M = na()
print(N * (N - 1) // 2 + M)


n, m = map (int, input().split())
ex1 = n*(n-1)/2
ex2 = m*(m-1)/2
ans = ex1 + ex2
print(ans)


import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.NoSuchElementException;
import java.util.concurrent.PriorityBlockingQueue;

public class Main {

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int n = sc.nextInt();
        int m = sc.nextInt();
        long ans = 0;

        ans += (n-1) * n / 2;
        ans += (m-1) * m / 2;

        System.out.println(ans);
    }

    private static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;

        private boolean hasNextByte() {
            if (ptr < buflen) {
                return true;
            } else {
                ptr = 0;
                try {
                    buflen = in.read(buffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (buflen <= 0) {
                    return false;
                }
            }
            return true;
        }

        private int readByte() {
            if (hasNextByte())
                return buffer[ptr++];
            else
                return -1;
        }

        private static boolean isPrintableChar(int c) {
            return 33 <= c && c <= 126;
        }

        public boolean hasNext() {
            while (hasNextByte() && !isPrintableChar(buffer[ptr]))
                ptr++;
            return hasNextByte();
        }

        public String next() {
            if (!hasNext())
                throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while (isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        public long nextLong() {
            if (!hasNext())
                throw new NoSuchElementException();
            long n = 0;
            boolean minus = false;
            int b = readByte();
            if (b == '-') {
                minus = true;
                b = readByte();
            }
            if (b < '0' || '9' < b) {
                throw new NumberFormatException();
            }
            while (true) {
                if ('0' <= b && b <= '9') {
                    n *= 10;
                    n += b - '0';
                } else if (b == -1 || !isPrintableChar(b)) {
                    return minus ? -n : n;
                } else {
                    throw new NumberFormatException();
                }
                b = readByte();
            }
        }

        public int nextInt() {
            long nl = nextLong();
            if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
                throw new NumberFormatException();
            return (int) nl;
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

}


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class Main
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int M = Integer.parseInt(st.nextToken());
         System.out.println(N*(N-1)/2+M*(M-1)/2);
      }
   }


import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    public boolean hasNext() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
        return hasNextByte();
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }

    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

public class Main {
    static int MOD = 1000000007;

    static int C(int n, int r) {
        int num = 1;
        for (int i = 1; i <= r; i++) {
            num = num * (n - i + 1) / i;
        }
        return num;
    }

    public static int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static long lcm(long a, long b) {
        long temp;
        long c = a;
        c *= b;
        while ((temp = a % b) != 0) {
            a = b;
            b = temp;
        }
        return (long) (c / b);
    }

    static long f(long n, Map<Long, Long> map) {
        if (n < 2)
            return 1;
        else if (map.containsKey(n)) {
            return map.get(n);
        } else {
            map.put(n, n * f(n - 2, map));
            return map.get(n);
        }

    }

    public static long factorial(long n) {
        return n <= 0 ? 1 : n * factorial(n - 1);
    }

    private static long calcLCM(long val1, long val2) {
        long maxValue = Math.max(val1, val2);
        long minValue = Math.min(val1, val2);
        long val3 = maxValue * minValue;

        if (minValue == 0)
            return maxValue;

        long temp;
        while ((temp = maxValue % minValue) != 0) {
            maxValue = minValue;
            minValue = temp;
        }

        return (long) (val3 / minValue);
    }

    static String nextPermutation(String s) {
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < s.length(); i++)
            list.add(s.charAt(i));

        int pivotPos = -1;
        char pivot = 0;
        for (int i = list.size() - 2; i >= 0; i--) {
            if (list.get(i) < list.get(i + 1)) {
                pivotPos = i;
                pivot = list.get(i);
                break;
            }
        }

        if (pivotPos == -1 && pivot == 0)
            return "Final";

        int L = pivotPos + 1, R = list.size() - 1;
        int minPos = -1;
        char min = Character.MAX_VALUE;
        for (int i = R; i >= L; i--) {
            if (pivot < list.get(i)) {
                if (list.get(i) < min) {
                    min = list.get(i);
                    minPos = i;
                }
            }
        }

        Collections.swap(list, pivotPos, minPos);
        Collections.sort(list.subList(L, R + 1));

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++)
            sb.append(list.get(i));

        return sb.toString();

    }

    public List<String> permutation(List<String> list, String target, String ans) {
        if (target.length() <= 1) {
            list.add(ans + target);
        } else {
            for (int i = 0; i < target.length(); i++) {
                permutation(list, target.substring(0, i) + target.substring(i + 1), ans + target.charAt(i));
            }
        }
        return list;
    }

    public static int lowerbound(int[] a, int key) {
        if (a[a.length - 1] < key)
            return a.length;
        int lb = 0, ub = a.length - 1, mid;
        do {
            mid = (ub + lb) / 2;
            if (a[mid] < key)
                lb = mid + 1;
            else
                ub = mid;
        } while (lb < ub);
        return ub;
    }

    public static int upperbound(int[] a, int key) {
        if (a[a.length - 1] <= key)
            return a.length;
        int lb = 0, ub = a.length - 1, mid;
        do {
            mid = (ub + lb) / 2;
            if (a[mid] <= key)
                lb = mid + 1;
            else
                ub = mid;
        } while (lb < ub);
        return ub;
    }

    public static int count(int[] a, int key) {
        return upperbound(a, key) - lowerbound(a, key);
    }

    public static void main(String[] args) {
        FastScanner fs = new FastScanner();
        int n = fs.nextInt();
        int m = fs.nextInt();

        System.out.println(C(n,2)+C(m,2));
    }

}


import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);

        String s = sc.next();
        String ans="Yes";
        int a=0;
        if(s.length()%2==1){
            a=1;
        }

        for(int i=0; i<s.length()/2; i++){
            if(s.charAt(i)!=s.charAt(s.length()-i-1)){
                ans="No";
                break;
            }
            if(s.charAt(i)!=s.charAt(s.length()/2-1-i)){
                ans="No";
                break;
            }
            if(s.charAt(s.length()/2+a)!=s.charAt(s.length()-i-1)){
                ans="No";
                break;
            }
        }

        System.out.println(ans);

	}
}


import java.util.Scanner;
public class Main {
  public static void main(String[] args) {
  Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int[] n = new int[N];
        for(int i=0; i<N; i++) {
          n[i] = sc.nextInt();
        }
    int M = sc.nextInt();
    int[] m = new int[N];
        for(int i=0; i<N; i++) {
          m[i] = sc.nextInt();
        }
    int cnt = 0;
    for(int i=0; i<=N; i++){
        if((m[i]+n[i])%2 == 0) {
            cnt++;
        } else {
          continue;
        }
      }
    }
    System.out.println(cnt);
  }
}


import java.util.Scanner;
public class Main {
  public static void main(String[] args) {
  Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int M = sc.nextInt();
    int cnt = 0;
    for(int i=0; i<=N; i++){
      for(int j=0; j<=M; j++){
        int k = i+j;
        if(k%2 == 0) {
            cnt++;
        } else {
          continue;
        }
      }
    }
    System.out.println(cnt);
  }
}


#include <stdio.h>

int main()
{
   int m, n;
   scanf("%d %d", &n, &m);

   printf ("%d\n", n*(n-1)/2 + m*(m-1)/2);

   return 0;
}


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() {
    int N,M;
    int ans;
    scanf("%d %d",&N,&M);

    ans = (N-1)*N/2 + (M-1)*M/2;
    printf("%d",ans);

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main() {
  int N,M;
  cin >>N>>M;
  if(N==1&&M==1){
    cout<<0<<endl;
    return 0;
  }else if(N==2&&M==2){
    cout<<2<<endl;
    return 0;
  }else{
    cout<<N*(N-1)/2+M*(M-1)/2<<endl;
  }
  return 0;
}


#include<bits/stdc++.h>
using namespace std;

int main(){
	int n,m;
	cin>>n>>m;

	cout<<((n*n-1)/2)+((m*m-1)/2);
}


#include<bits/stdc++.h>
using namespace std;

int main(){
	int n,m;
	cin>>n>>m;

	cout<<((n*n-1)/2)+((n*n-1)/2);
}


#include<stdio.h>
int main(){
  int M, N;
    scanf("%d %d", &M, &N);
  int a=1;
  int b=1;
  //int b=1;
  int genap, ganjil;
  int arraygenap[M], arrayganjil[N];
  int z=0;

  for(int i=1; i<=M; i++){
    genap= 2*a;
    arraygenap[i]=genap;
    a++;
  }
  getchar();
  for(int i=1; i<=N; i++){
    ganjil= 3*b;
    arrayganjil[i]=ganjil;
    b++;
  }
  for(int i=0; i<M; i++){
    for(int x=0; x<N; x++){
         if((arrayganjil[i]+arraygenap[x])%2==0){
           z=i+x;
         }else{}

    }
  }
    printf("%d", z);
    return 0;
  }


#include<stdio.h>

int main(){
  int n,m;

  scanf("%d %d",&n, &m);
  printf("%d\n", (n+m)*(n+m-1)/2-n*m);
  return 0;
}


#include<stdio.h>

int main(){
	int N;
	scanf("%d", &N);
	int M;
	scanf("%d", &M);
	int n_even = (N * (N - 1)) / 2;
	int n_odd = (M * (M - 1)) / 2;

	if(N == 0 && M > 0)
		printf("%d", n_odd);
	else if(M == 0 && N > 0)
		printf("%d", n_even);
	else
		printf("%d", n_odd + n_even);
	return 0;
}


#include <stdio.h>

int main(){
	int N,M;
  	scanf("%d %d", &N, &M);

  	int ans;
  	ans = N*(N-1)/2 + M*(M-1)/2;

    printf("%d",ans);
}


#include <stdio.h>
int main(){
	int a, b, n, sum=0;
	scanf("%d", &a);
	for(int i=0; i<a; i++){
		scanf("%d", &n);
    	while(n>0){
    	b=n%10;
		n=n/10;
		sum+=b;
		}
		printf("%d\n", sum);
	}
return 0;
}


#include <stdio.h>

int main(){
	int N; int even = 0;
	int M; int odd = 0;
	scanf ("%d %d", &N, &M);

	for (int i=0; i <= N; i++){
		even = even +i-1;
	}
	for(int i=0; i <= M; i++){
		odd = odd +i-1;
	}
	printf ("%d", odd+even);

	return 0;
}


#include<stdio.h>

int main ()
{

  int n,m;

  scanf("%d %d",&n,&m);

  printf("%d",comb(n,2)+comb(m,2));

}

int comb(int a,int b)
{
  int i;
  int fact1=1;
  int fact2=1;
  int fact3=1;

  for(i=1;i<=a;i++)
  {
  fact1=fact1*i;
   // fact1=fact1 % modb;
   // printf("%d\n",fact1);
  }
  for(i=1;i<=b;i++)
  {
  fact2=fact2*i;
  //  fact2=fact2 % modb;
  }
  for(i=1;i<=a-b;i++)
  {
  fact3=fact3*i;
   // fact3=fact3 % modb;
  }

  return (fact1/fact2/fact3);
}


function Main(input) {
    var tmp = input.split(" ");
    var N = parseInt(tmp[0],10);
    var M =parseInt(tmp[1],10);

    //組み合わせの考え方
    //偶数＋偶数＝偶数(1)
    //奇数＋偶数＝奇数(2)
    //奇数＋奇数＝偶数(3)
    //であるため
    //(1)=N*(N-1),(3)=M*(M-1)の和が
    //N+Mのボールから任意の2のボールを取るときの偶数となる場合の数となる。

        console.log((N*(N-1)+M*(M-1))/2);

}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


const s_list = require('fs').readFileSync('/dev/stdin', 'utf8').split(' ');
const n_list = s_list.map(s => parseInt(s, 10));
const n = n_list[0];
const m = n_list[1];

const ans_n = n > 1 ? n * (n - 1) / 2 : 0
const ans_m = m > 1 ? m * (m - 1) / 2 : 0
const ans = ans_n + ans_m
console.log(ans)


'use strict';
function main(input) {
  input = input.split(' ');
  const a = parseInt(input[0], 10);
  const b = parseInt(input[1], 10);

  const sum = (a > 1 ? a * (a - 1) / 2 : 0) + (b > 1 ? b * (b - 1) / 2 : 0)

  console.log(sum);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
	var str = input;
	var ans = 0;
	var str = str.split("\n")[0];
	var num = str.split(" ");
	var n = Number(num[0]);
	var m = Number(num[1]);

	if(n >1){
		n = n*(n-1)/2;
	}
	if(m>1){
		m = m*(m-1)/2;
	}
	ans = n+m;
		console.log(ans);
	}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


'use strict';
function main(input) {
  input = input.split(' ');
  const a = parseInt(input[0], 10);
  const b = parseInt(input[1], 10);

  sum = (a > 1 ? a * (a - 1) / 2 : 0) + (b > 1 ? b * (b - 1) / 2 : 0)

  console.log(sum);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
    var tmp = input.split(" ");
    var L = parseInt(input,10);

    //-input
    //L=正の整数

    //-output
    //L=x+y+zを満たす直方体の体積S=x*y*z

    console.log(Math.pow(L/3,3));

}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	sc.Split(bufio.ScanWords)

	n := nextInt()
	m := nextInt()

	gg := 0 // 偶数+偶数
	kk := 0 // 奇数+奇数

	if n >= 2 {
		gg = n * (n - 1) / 2
	}
	if m >= 2 {
		kk = m * (m - 1) / 2
	}

	fmt.Println(gg + kk)

}

// ---- readfunc
func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}


package main

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

var stdInScanner = bufio.NewScanner(os.Stdin)

func nextInt() int {
	stdInScanner.Scan()
	i, _ := strconv.Atoi(stdInScanner.Text())
	return i
}

func main() {
	stdInScanner.Split(bufio.ScanWords)

	N := nextInt()
	M := nextInt()

	// 全て偶数(nC2)
	a := (N * (N - 1)) / 2
	// すべて奇数(mC2)
	b := (M * (M - 1)) / 2
	fmt.Println(a + b)
}


package main

import (
	"fmt"
)

func combinationTwo(a int)int{
	return a * (a-1) / 2
}

func main() {
	var even, odd int
	fmt.Scan(&even, &odd)
	// even2個、odd2個で偶数になる
	// even C 2 + odd C 2の組み合わせが答え

	ans := 0
	if even >= 2 && odd >= 2{
		ans = combinationTwo(even) + combinationTwo(odd)
	}else if even >= 2 && odd < 2{
		ans = combinationTwo(even)
	}else if even < 2 && odd >= 2{
		ans = combinationTwo(odd)
	}

	fmt.Println(ans)
}


#include <bits/stdc++.h>
using namespace std;
int main () {
  int n, m;
  cin >> n >> m;
  cout << ((n * (n-1) + m * (m-1)) / 2) << "\n";
}


package main
import (
    "fmt"
)

func main(){
    var n, m int
    fmt.Scanf("%d:%d", &n, &m);
    ans := n * (n - 1) / 2 + m * (m - 1)
    fmt.Println(ans)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"reflect"
	"strings"
)

// 元の文字列と逆順にした文字列、そして回文かどうかを真偽値で返す
func GetPalindrome(slice []string) bool {
	sre := make([]string, 0)

	for i := len(slice) - 1; i >= 0; i-- {
		sre = append(sre, slice[i])
	}
	if reflect.DeepEqual(slice, sre) {
		return true
	}
	return false
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)

	scanner.Scan()

	scan := scanner.Text()

	slice := strings.Split(scan, "")

	if len(slice) < 7 {
		fmt.Println("No")
		os.Exit(0)
	}

	flag := GetPalindrome(slice)

	if flag == false {
		fmt.Println("No")
		os.Exit(0)
	}

	flag = GetPalindrome(slice[:(len(slice)-1)/2])

	if flag == false {
		fmt.Println("No")
		os.Exit(0)
	}

	flag = GetPalindrome(slice[((len(slice)+3)/2)-1:])

	if flag == false {
		fmt.Println("No")
		os.Exit(0)
	}

	fmt.Println("Yes")

}


n, m = gets.split.map(&:to_i)

puts n*(n-1) / 2 + m*(m-1) / 2


a,b = gets.split.map(&:to_i)
puts (a * (a-1) / 2) + (b * (b-1) / 2)


n,m = gets.split.map(&:to_i)
puts (n*(n-1) + m*(m-1))/2


n,m = gets.chomp.split(' ').map(&:to_i)
puts ((m + n)*(m + n - 1) - m * (m - 1)) / 2


n,m = gets.chomp.split(' ').map(&:to_i)
puts ((m + n)*(m + n - 1) - n * (n - 1)) / 2


x,y=gets.split.map!(&:to_i)
ans1=0
ans2=0
if x>2
  for i in 1..x-1
    ans1+=i
  end
else
  ans1=x-1
end
if y>2
  for j in 1..y-1
    ans2+=j
  end
else
  ans2=y-1
end
puts ans1+ans2


#[allow(unused_macros, dead_code)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros, dead_code)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros, dead_code)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(dead_code)]
struct UnionFind {
    parent: Vec<usize>,
    rank: Vec<usize>,
    size: Vec<usize>,
}

#[allow(dead_code)]
impl UnionFind {
    fn new(n: usize) -> UnionFind {
        let mut p = vec![0; n];
        for i in 0..n {
            p[i] = i;
        }
        return UnionFind {
            parent: p,
            rank: vec![0; n],
            size: vec![1; n],
        };
    }

    fn find(&mut self, x: usize) -> usize {
        if x == self.parent[x] {
            x
        } else {
            let p = self.parent[x];
            let pr = self.find(p);
            self.parent[x] = pr;
            pr
        }
    }

    fn same(&mut self, a: usize, b: usize) -> bool {
        self.find(a) == self.find(b)
    }

    fn unite(&mut self, a: usize, b: usize) {
        let a_root = self.find(a);
        let b_root = self.find(b);
        if a_root == b_root {
            return;
        }
        if self.rank[a_root] > self.rank[b_root] {
            self.parent[b_root] = a_root;
            self.size[a_root] += self.size[b_root];
        } else {
            self.parent[a_root] = b_root;
            self.size[b_root] += self.size[a_root];
            if self.rank[a_root] == self.rank[b_root] {
                self.rank[b_root] += 1;
            }
        }
    }

    fn get_size(&mut self, x: usize) -> usize {
        let root = self.find(x);
        self.size[root]
    }
}

const MOD_P: usize = 1000000007;

#[allow(dead_code)]
// fact(n) = n! mod p
fn fact(n: usize) -> usize {
    let mut acc = 1;
    for i in 1..n + 1 {
        acc = acc * i % MOD_P;
    }
    acc
}

#[allow(dead_code)]
fn mod_pow(b: usize, mut e: usize) -> usize {
    let mut base = b;
    let mut acc = 1;

    while e > 1 {
        if e % 2 == 1 {
            acc = acc * base % MOD_P;
        }
        e /= 2;
        base = base * base % MOD_P;
    }

    if e == 1 {
        acc = acc * base % MOD_P;
    }

    acc
}

#[allow(dead_code)]
fn comb(n: usize, r: usize) -> usize {
    // nCr = n! / (r! (n-r)!) = n! (r!)^(p-2) ((n-r)!)^(p-2)
    fact(n) * mod_pow(fact(r), MOD_P - 2) % MOD_P * mod_pow(fact(n - r), MOD_P - 2) % MOD_P
}

#[allow(dead_code)]
fn gcd(a: usize, b: usize) -> usize {
    if b > a {
        gcd(b, a)
    } else if a % b == 0 {
        b
    } else {
        gcd(b, a % b)
    }
}

#[allow(dead_code)]
fn getline() -> String {
    let mut __ret = String::new();
    std::io::stdin().read_line(&mut __ret).ok();
    return __ret;
}

use std::cmp::{max, min};

fn main() {
    input! {
        n: isize,
        m: isize,
    }
    let ans = n * max(0, n - 1) / 2 + m * max(0, m - 1) / 2;
    println!("{}", ans);
}


/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
/* }}} */

fn main() {
    input! {
        n: u32,
        m: u32
    }
    println!("{}",
        n * (n-1) / 2 +
        m * (m-1) / 2);
}
/* vim:set foldmethod=marker: */


#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

use std::iter::Iterator;

fn main() {
    input! {
        N: usize,
        M: usize,
    }

    let mut  n = N;

    if N == 0 {
        n = 1
    }

    let mut m = M;

    if M == 0 {
        m = 1
    }

    println!("{}", (m* (m-1) + n*(n-1))/2);

}


// https://atcoder.jp/contests/abc159/tasks/abc159_a

use proconio::input;

fn main() {
    input! { n: i8, m: i8, }
    println!("{}", n * (n - 1) / 2 + m * (m - 1) / 2);
}


use proconio::input;
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

#[allow(non_snake_case)]
fn main() {
    input! {
        N:usize,
        M:usize,
    }
    let mut ans = 0;
    if N > 0 {
        ans += N * (N - 1) / 2;
    }
    if M > 0 {
        ans += M * (M - 1) / 2;
    }
    println!("{}", ans);
}


use proconio::input;

fn main() {

    input! {
        n: i32,
        m: i32,
    };

    let na = (n*(n-1)) / 2;
    let nb = (m*(m-1)) / 2;

    print!("{}", na+nb);
}


import Foundation
let array = readLine()!.componentsSeparatedByString(" ").map{ Int($0)! }
var a = Int(array[0])
var b = Int(array[1])
var c = a*(a-1)/2 + b*(b-1)/2
print(c)


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

func main() {
    let line = readInts()
    let n = line[0]
    let m = line[1]

    print(n * (n - 1) / 2 + m * (m - 1) / 2)
}

main()


import Foundation

let split = readLine()!.componentsSeparatedByString(" ")

let N = Int(split[0])!
let M = Int(split[1])!
let combination = (N * (N - 1) / 2) + (M * (M - 1) / 2)
print(combination)


import Foundation
let array = readLine()!.componentsSeparatedByString(" ").map{ Int($0)! }
var a = Int(array[0])!
var b = Int(array[1])!
var c = a*(a-1)/2 + b*(b-1)/2
print(c)


import Foundation
let array = readLine()!.componentsSeparatedByString(" ").map{ Int($0)! }
var a = int(array[0])
var b = int(array[1])
var c = a*(a-1)/2 + b*(b-1)/2
print(c)


import Foundationimport Foundation
let input = readLine()!.componentsSeparatedByString(" ")
let N = Int(input[0])!
let M = Int(input[1])!

let sum = N * (N - 1) / 2 + M * (M - 1) / 2
print(sum)


export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [n, m]: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    return `${((n + m) * (n + m - 1) / 2) - (n * m)}`;
  }
}
console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));


function main(input) {
  const inputs =input.split('\n')
  const [N, M] = inputs[0].split(' ').map(Number)
  console.log(
    (N + M) * (N + M -1) / 2 - (N * M)
  )

}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


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 Main({ int, str, strs, ints }: NormalInput) {
  const [N,M ]= ints(2);
  console.log(N*(N-1)/2+M*(M-1)/2);
}

//DO NOT EDIT
Main(new NormalInput(require("fs").readFileSync("/dev/stdin", "utf8")));


function Main(input: string) {
  const length = input.length;
  const a = check(input);
  const b = check(input.substr(0, (length  -1)/2 ));
  const c = check(input.substr((length +3)/2 - 1))
  console.log(a && b && c ? 'Yes': 'No');
}

function check(str: string) {
  const length = str.length;
  for (let i = 0; i < Math.floor(length / 2); i++) {
    if (str.charAt(i) !== str.charAt(length - i - 1))return false;
  }
  return true;
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input: string) {
  const length = input.length ;
  const a = check(input);
  const b = check(input.slice(0, (length  -1)/2 ));
  const c = check(input.slice((length +3)/2 -1, length ))
  console.log(a && b && c ? 'Yes': 'No');
}

function check(str: string) {
  const length = str.length;
  for (let i = 0; i < length / 2; i++) {
    if (str.charAt(i) !== str.charAt(length - i - 1))return false;
  }
  return true;
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


import math
n = int(input())
a =[int(input()) for _ in range(5)]
print(math.ceil(n / min(a)) + 4)


# -*- coding: utf-8 -*-
import math

# スペース区切りの整数の入力
N = int(input())
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())

bottle_neck=min(A,B,C,D,E)

ans= 4 + math.ceil(N/bottle_neck)

print(ans)


n = int(input())
data = [int(input()) for i in range(5)]
bn = min(data)
print(-(-n//bn)+4)


n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
k=min(a,b,c,d,e)
print(n//k + 5)


n=int(input())
t=[int(input()) for i in range(5)]
k=0
for i in range(5):
    k=max(k,(n//t[i]))
print(5+k)


N = int(input())
T = []
for i in range(5):
    T.append(int(input()))
k = 0
for i in range(4):
    if N % T[i] == 0:
        k = max(k, N//T[i])
    else:
        k = max(k, N//T[i] + 1)
print(4 + k)


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {
    long[] a;
    long N;
    private void solve() {
        N = nextLong();

        a = new long[5];
        long min = Long.MAX_VALUE;
        for(int i = 0;i < 5;i++) {
            a[i] = nextLong();
            min = Math.min(min, a[i]);
        }

        long ans = 5;
        N = Math.max(N - min, 0);
        ans += N / min;
        ans += (N % min > 0 ? 1 : 0);
        out.println(ans);

    }

    public static void main(String[] args) {
        out.flush();
        new Main().solve();
        out.close();
    }

    /* Input */
    private static final InputStream in = System.in;
    private static final PrintWriter out = new PrintWriter(System.out);
    private final byte[] buffer = new byte[4096];
    private int p = 0;
    private int buflen = 0;

    private boolean hasNextByte() {
        if (p < buflen)
            return true;
        p = 0;
        try {
            buflen = in.read(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (buflen <= 0)
            return false;
        return true;
    }

    public boolean hasNext() {
        while (hasNextByte() && !isPrint(buffer[p])) {
            p++;
        }
        return hasNextByte();
    }

    private boolean isPrint(int ch) {
        if (ch >= '!' && ch <= '~')
            return true;
        return false;
    }

    private int nextByte() {
        if (!hasNextByte())
            return -1;
        return buffer[p++];
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = -1;
        while (isPrint((b = nextByte()))) {
            sb.appendCodePoint(b);
        }
        return sb.toString();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}