jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [javascript]

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'));
//  [javascript]
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"));
//  [javascript]
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'));
//  [javascript]
'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'));
//  [javascript]
"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"); 
}
//  [javascript]
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'));
//  [go]
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)
}
//  [go]
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)
}
//  [go]
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")
	}
}
//  [go]
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, "")
}
//  [go]
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)
}
//  [go]
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
}
//  [ruby]
d = gets.to_i
d -= 25

print 'Christmas'

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

print "\n"
//  [ruby]
a = "Christmas"
d = gets.chomp.to_i.upto(24){a += " Eve"}
puts a
//  [ruby]
D=gets.to_i
s='Christmas'
(25-D).times{
	s+=' Eve'
}
puts s
//  [ruby]
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
//  [ruby]
print "Christmas"
for i in 25-gets.to_i do
  print " Eve"
end
puts ""
//  [ruby]
puts"Christmas"+" Eve"*(103-`dd`.sum)
//  [rust]
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);
}
//  [rust]
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",
            _ => "",
        },
    )
}
//  [rust]
#[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);

}
//  [rust]
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);
}
//  [rust]
fn main() {
    input! { mut d: usize }
    let mut ret: String = "Christmas".to_string();
    while d < 25 {
        ret.push_str(" Eve");
        d += 1;
    }
    println!("{}", ret);
}
//  [rust]
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);
}
//  [swift]
//作成日：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")
}
//  [swift]
let D = Int(readLine()!)!
print("Christmas" + String(repeating: " Eve", count: 25-D))
//  [swift]
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)
//  [swift]
var a = readLine()!
var c = Int(a)!
var b = readLine()!
var d = Int(b)!
print(6 - c - d)
//  [swift]
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")
//  [swift]
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")
}
}
//  [typescript]
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());
}
//  [typescript]
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;
}
//  [typescript]
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();
//  [typescript]
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'));
//  [python]
a, b, c  = map(int, input().split())
if a <= c <= b:
    print('Yes')
else:
    print('No')
//  [python]
A,B,C=map(int, input().split())
if C>=A and C<=B:
  print("Yes")
else:
  print("No")
//  [python]
def main():
    A, B, C = map(int, input().split())

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

main()
//  [python]
A,B,C = map(int, input().split())

if C > A and C < B:
    print('Yes')
else:
    print('No')
//  [python]
a,b,c = map(int,input().split())

if a<=b and b<=c:
    print('Yes')
else:
    print('No')
//  [python]
A, B, C = map(int, input().split())
print("YES" if C >= A and C <= B else "No")
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Main{
	public static void main(String[]args)throws IOException{
	
		BufferedReader br=
				new BufferedReader(new InputStreamReader(System.in));
		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");
		}
	}
	}
//  [java]
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");
    }
  }
}
//  [java]
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;
		}
	}
}
//  [java]
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");
      }
          
	}
}
//  [java]
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');
      }
          
	}
}
//  [java]
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;
		}
	}
}
//  [cpp]
#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;
}
//  [cpp]
#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");
}
//  [cpp]
#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");
}
//  [cpp]
#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;
}
//  [cpp]
#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;
}
//  [cpp]
#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";
 }
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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");
    }
}
//  [c]
#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);
}
//  [c]
#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);
}
//  [c]
#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;
}
//  [javascript]
'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'))
//  [javascript]
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"));
//  [javascript]
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'));
//  [javascript]
// 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"));
//  [javascript]
// 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"));
//  [javascript]
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"));
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [ruby]
a,b,c = gets.chomp.split(' ').map(&:to_i)
if a <= c && b >= c
  puts "Yes"
else
  puts "No"
end
//  [ruby]
a,b,c=gets.split.map(&:to_i);puts c >= a && c < b || a == b ? "Yes" : "No"
//  [ruby]
A, B, C = gets.split.map{|i|i.to_i}
puts (A <= C && C <= B ? "Yes" : "No")
//  [ruby]
a, b, c = gets
if c >= a && c <= b
  puts 'YES'
else
  puts 'NO'
//  [ruby]
a,b,c=gets.split.map(&:to_i)
puts (a..b).include? c ? "Yes" : "No"
//  [ruby]
a,b,c = gets.chomp.split.map(&:to_i)
if [a,b,c].sort[1] == c
  puts "Yes"
else
  puts "No"
end
//  [rust]
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");
	}
}
//  [rust]
#![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"});
}
//  [rust]
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")
    }
}
//  [rust]
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");

   }

}
//  [rust]
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" });
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[0]>i[2]||i[2]>i[1] ?"No":"Yes")
//  [swift]
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)
//  [swift]
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)
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[0]<i[2]&&i[2]<=i[1] ?"Yes":"No")
//  [typescript]
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");
//  [typescript]
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');
}
//  [typescript]
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'));
//  [typescript]
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()
//  [typescript]
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()
//  [typescript]
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'));
//  [python]
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)
//  [python]
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))
//  [python]
n, m = map(int, input().split())
print( n * (n - 1) // 2 + m * (m - 1) // 2)
//  [python]
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)
//  [python]
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)
//  [python]
n, m = map (int, input().split())
ex1 = n*(n-1)/2
ex2 = m*(m-1)/2
ans = ex1 + ex2
print(ans)