jiahuimbzuai/CoQuIR huggingface dataset:
//  [swift]
import Foundation

let input_line: String = readLine()!

let n: Int = Int(input_line)!

let input_line2: String = readLine()!
let split2: [String] = input_line2.components(separatedBy: " ") //ブランクで区切られている場合
var array: [Int] = []

for a in split2 {
    array.append(Int(a)!)
}

var ansArray: [Int] = Array(repeating: 0, count: n-1)

for a in array {
    if a == 0 {
    } else {
        ansArray[a-1] += 1
    }
}

ansArray.append(0)

for ans in ansArray {
    print(ans)
}
//  [swift]
import Foundation

let N = Int(readLine()!)!
let managerCodeList = readLine()!.components(separatedBy: " ").map({return Int($0)!})
var bukaCountList = Array<Int>(repeating: 0, count: N)

managerCodeList.forEach({
    bukaCountList[$0-1] += 1
})

bukaCountList.forEach{
    print($0)
}
//  [typescript]
export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [n]: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    const a: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    const map = {};
    for (let i = 0, len = n - 1; i < len; 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"));
//  [typescript]
import * as fs from 'fs'

const input = fs.readFileSync('/dev/stdin', 'utf8');
const args: string[][] = input.split('\n').map(l => l.split(' '));

const n = parseInt(args[0][0])
const a = args[1].map(x => parseInt(x));

const m = Array(n).fill(0);

a.forEach(x => {
  m[x - 1]++;
});

m.forEach(x => {
  console.log(x);
})
//  [typescript]
import * as fs from 'fs'
import {debug} from '../../util'
const output = (x: any) => console.log(x)

const input = fs.readFileSync('/dev/stdin', 'utf8').split('\n')
const [N] = input[0].split(' ').map(n => parseInt(n, 10))
const A = input[1].split(' ').map(n => parseInt(n, 10))
const counter = Array(N).fill(0)
A.map(a => {
    counter[a-1]++
})
counter.map(count => output(count))
//  [python]
import numpy as np

# 初期値を入力

D = int(input())

# メインプログラム

if D == 22:
    print("Christmas Eve Eve Eve")
elif D == 23:
    print("Christmas Eve Eve")
elif D == 24:
    print("Christmas Eve")
elif D == 25:
    print("Christmas")
//  [python]
# -*- coding: utf-8 -*-
"""
Created on Sat Dec  8 20:50:49 2018

@author: Owner
"""


import collections
import scipy.misc
import sys
import numpy as np
import math
from operator import itemgetter

def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []

"""
N, X = map(int, input().split())

x = [0]*N
x[:] = map(int, input().split())

P = [0]*M
Y = [0]*M
for m in range(M):
    P[m], Y[m] = map(int, input().split())
    
all(nstr.count(c) for c in '753')
"""

D = int(input())

if D == 25:
    print('Christmas')
elif D == 24:
    print('Christmas Eve')
elif D == 23:
    print('Christmas Eve Eve')
elif D == 22:
    print('Christmas Eve Eve Eve')
//  [python]
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = 10**18
# ----------------------------------------------------------- #

d = I()
if d == 25:
    print("Christmas")
elif d == 24:
    print("Christmas Eve")
elif d == 23:
    print("Christmas Eve Eve")
else:
    print("Christmas Eve Eve Eve")
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int d = sc.nextInt();
        System.out.print("Christmas");
        IntStream.range(0, 25-d)
                .forEach(i -> {
                    System.out.print(" Eve");
                });
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.*;

public class Main implements Runnable {

    public static void main(String[] args) throws Exception {
        Thread.setDefaultUncaughtExceptionHandler((t, e)->System.exit(1));
        new Thread(null, new Main(), "", 16 * 1024 * 1024).start();
    }

    public void run() {
        int D = 0;
        
        // 入力
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in));) {
            D = Integer.parseInt(br.readLine());
        } catch (Exception e) {
            e.printStackTrace();
        }
        String result = "";
        switch (D) {
            case 25:
            result = "Christmas";
            break;
            case 24:
            result = "Christmas Eve";
            break;
            case 23:
            result = "Christmas Eve Eve";
            break;
            case 22:
            result = "Christmas Eve Eve Eve";
            break;
        }

        // 出力
        System.out.println(result);
    }
}
//  [java]
import java.io.*;
import java.util.StringTokenizer;

public class Main {
  private static PrintWriter out;

  public static void main(String[] args) {
    Main main = new Main();
    Runtime.getRuntime().addShutdownHook(new Thread(() -> out.close()));
    try {
      main.run(args);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private void run(String[] arguments) throws Exception {
    MyScanner sc = new MyScanner();
    out = new PrintWriter(new BufferedOutputStream(System.out));
    int D = sc.nextInt();
    switch (D) {
      case 25:
        out.println("Christmas");
        break;
      case 24:
        out.println("Christmas Eve");
        break;
      case 23:
        out.println("Christmas Eve Eve");
        break;
      case 22:
        out.println("Christmas Eve Eve Eve");
    }
  }

  /*
   * Form: http://codeforces.com/blog/entry/7018
   */
  private class MyScanner {
    BufferedReader br;
    StringTokenizer st;

    MyScanner() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
      while (st == null || !st.hasMoreElements()) {
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }

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

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

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

    String nextLine() {
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }
  }
}
//  [cpp]
#include <cstdio>

using namespace std;

int main()
{
    int d;
    scanf("%d", &d);
    if(d == 25)
        printf("Christmas\n");
    else if(d == 24)
        printf("Christmas Eve\n");
    else if(d == 23)
        printf("Christmas Eve Eve\n");
    else if(d == 22)
        printf("Christmas Eve Eve Eve\n");
    return 0;
}
//  [cpp]
#include<iostream>
#include <stdlib.h>
#include <algorithm>
#include <string>
#include <math.h>
typedef long long int ll;
using namespace std;
int main(){
	int n;
	cin >> n;
	if(n==25){
		cout<< "Christmas"<<endl;
	}else if(n==24){
		cout<<"Christmas Eve"<<endl;
	}else if(n==23){
		cout<<"Christmas Eve Eve"<<endl;
	}else{
		cout<<"Christmas Eve Eve Eve"<<endl;
	}
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
 
  int d;
  cin>>d;
  string ans="";
  if(d==25)ans="Christmas";
  if(d==24)ans="Christmas Eve";
  if(d==23)ans="Christmas Eve Eve";
  if(d==22)ans="Christmas Eve Eve Eve";
  cout(ans);
 
  return 0;
}
//  [c]
#include <stdio.h>
int main()
{
    int D;
    scanf("%d",&D);
    if(D==25){
        printf("Christmas\n");
    }
    if(D==24){
        printf("Christmas Eve\n");
    }
    if(D==23){
        printf("Christmas Eve Eve\n");
    }
    if(D==22){
        printf("Christmas Eve Eve Eve\n");
    }
    return 0;
}
//  [c]
#include<stdio.h>
int main(void){
  int d;
  scanf("%d",&d);
  printf( "Christmas");
for(int i=d;i<25;i++) printf( " Eve");
printf("\n");
}
//#D=24 なら Christmas Eve, D=23 なら Christmas Eve Eve, D=22 なら Christmas Eve Eve Eve
//  [c]
#include<stdio.h>
int main(void)
{
    int D;
    
    scanf("%d",&D);
  
    if(D==25) printf("Christmas\n");
    else if(D==24) printf("Christmas Eve\n");
    else if(D==23) printf("Christmas Eve Eve\n");
    else printf("Christmas Eve Eve Eve\n");
  
    return 0;
}
//  [javascript]
'use strict'

const main = (INPUT) => {
  const N = INPUT.split('\n')[0]
  if (N == 25) {
    console.log('Christmas');
  } else if (N == 24) {
    console.log('Christmas Eve');
  } else if (N == 23) {
    console.log('Christmas Eve Eve');
  } else if (N == 22) {
    console.log('Christmas Eve Eve Eve');
  }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
"use strict";

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function main(input) {
  var lines = input.split('\n');

  var _splitNum = splitNum(lines.shift()),
      _splitNum2 = _slicedToArray(_splitNum, 1),
      D = _splitNum2[0];

  switch (D) {
    case 25:
      console.log('Christmas');
      return;

    case 24:
      console.log('Christmas Eve');
      return;

    case 23:
      console.log('Christmas Eve Eve');
      return;

    case 22:
      console.log('Christmas Eve Eve Eve');
      return;
  }
}

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

function splitNum(line) {
  return line.split(/\s+/).map(function (n) {
    return parseInt(n);
  });
}
//  [javascript]
function main(input) {
    const args = input.split(' ');
    const D = parseInt(args[0], 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'));
//  [go]
package main

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

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

var reader = bufio.NewReader(os.Stdin)

func Scan(a ...interface{}) {
	if _, err := fmt.Fscan(reader, a...); err != nil {
		panic(err)
	}
}
func ReadInt() (i int)       { Scan(&i); return }
func ReadString() (s string) { Scan(&s); return }
func ReadInts(n int) []int {
	v := make([]int, n)
	for i := 0; i < n; i++ {
		Scan(&v[i])
	}
	return v
}
//  [go]
package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
)

var sc = bufio.NewScanner(os.Stdin)

func init() {
	buf := make([]byte, initialBufSize)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords)
}

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

func main() {
	d := "Christmas"
	switch nextInt() {
	case 24:
		d += " Eve"
	case 23:
		d += " Eve Eve"
	case 22:
		d += " Eve Eve Eve"
	}
	fmt.Println(d)
}
//  [ruby]
d = gets.to_i
puts "Christmas" + (" Eve" * (25 - d))
//  [ruby]
s=["Christmas","Christmas Eve","Christmas Eve Eve","Christmas Eve Eve Eve"]
puts s[25-gets.to_i]
//  [ruby]
n = gets.to_i
case n
when 25
  puts "Christmas"
when 24
  puts "Christmas Eve"
when 23
  puts "Christmas Eve Eve"
when 22
  puts "Christmas Eve Eve Eve"
end
//  [rust]
use proconio::{input, fastout};

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

#[fastout]
fn main() {
    input!{
        d: usize,
    }

    match d {
        22 => println!("Christmas Eve Eve Eve"),
        23 => println!("Christmas Eve Eve"),
        24 => println!("Christmas Eve"),
        25 => println!("Christmas"),
        _ => return,
    }

}
//  [rust]
use std::io;
use std::str::FromStr;

fn input<T:FromStr>() -> T {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().parse().ok().unwrap()
}

fn main() {
    let d: u64 = input();
    match d {
        25 => println!("Christmas"),
        24 => println!("Christmas Eve"),
        23 => println!("Christmas Eve Eve"),
        22 => println!("Christmas Eve Eve Eve"),
        _ => println!("No")
    }
}
//  [rust]
use proconio::input;
// use std::collections::HashMap;

#[allow(non_snake_case)]
fn main() {
    input! {
        D: i32,
    }

    if D == 22 {
        println!("Christmas Eve Eve Eve");
    } else if D == 23 {
        println!("Christmas Eve Eve");
    } else if D == 24 {
        println!("Christmas Eve");
    } else {
        println!("Christmas");
    }


}
//  [swift]
print("Christmas"+String(repeating:" Eve",count:25-Int(readLine()!)!))
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    func count() -> Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
}
extension Array where Element: Comparable {
    func max() -> Element! {
        return self.maxElement()
    }
    func min() -> Element! {
        return self.minElement()
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let D = readInt()!
var str = ""
switch D {
case 22:
    str = "Christmas Eve Eve Eve"
case 23:
    str = "Christmas Eve Eve"
case 24:
    str = "Christmas Eve"
case 25:
    str = "Christmas"
default:
    break
}
print(str)
//  [typescript]
const lines=[];
const reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

reader.on('line', function (line) {
  lines.push(line);
});
reader.on('close', function () {
    const input = (lines[0] as string).split(" ");
    const a = +input[0];
    if (a == 25) {console.log("Christmas");} 
    if (a == 24) {console.log("Christmas Eve");} 
    if (a == 23) {console.log("Christmas Eve Eve");} 
    if (a == 22) {console.log("Christmas Eve Eve Eve");} 
});
//  [typescript]
const funcA = (input: string): void => {
    const message = (): string => {
        switch (Number(input)) {
            case 22: return 'Christmas Eve Eve Eve'
            case 23: return 'Christmas Eve Eve'
            case 24: return 'Christmas Eve'
            case 25: return 'Christmas'
        }
    }
    console.log(message());
}
funcA(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
console.log('Christmas'+' Eve'.repeat(25-require('fs').readFileSync('/dev/stdin','utf8')))
//  [python]
A, B, C = map(int, input().split())
 
if (C >= A) & (C <= B):
  print("Yes")
else:
  print("No")
//  [python]
import numpy as np

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

if C >= A and C<=B:
    print ('Yes')
else:
    print ('No')
//  [python]
# region header
import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**6)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
# endregion
A, B, C = ri_()
print('Yes' if A <= C <= B else 'No')
//  [java]
import java.io.*;
import java.lang.*;
import java.util.*;
import java.math.*;

class Solver extends Main{
	Solver(){

	}
}

class Main{
	int imax=Integer.MAX_VALUE;
	long lmax=Long.MAX_VALUE;
	public static void main(String[] args) throws FileNotFoundException{
		Scanner sc=new Scanner(System.in);
		int[] num=readlnI(sc," ");
		puts( num[2]>=num[0] && num[2]<=num[1] ? "Yes" : "No" );
		new Solver();
	}	
	
	//utility
	static int[] readlnI(Scanner sc, String dl){
		return Arrays.stream(sc.nextLine().trim().split(dl)).mapToInt(Integer::parseInt).toArray();
	}
	static long[] readlnL(Scanner sc, String dl){
		return Arrays.stream(sc.nextLine().trim().split(dl)).mapToLong(Long::parseLong).toArray();
	}
	static int readI(Scanner sc){
		return Integer.parseInt(sc.nextLine().trim());
	}
	static String[] readS(Scanner sc, String dl){
		return sc.nextLine().trim().split(dl);
	}
	static String nextS(Scanner sc){
		return sc.nextLine().trim();
	}
	@SuppressWarnings("unchecked")
	static <T> void puts(T... args){
		for(int i=0; i<args.length-1; i++){
			System.out.printf("%s ",args[i]);
		}
		System.out.println(args[args.length-1]);
	}
	static void puts(int[] ary){
		for(int i=0; i<ary.length-1; i++){
			System.out.printf("%d ",ary[i]);
		}
		System.out.println(ary[ary.length-1]);
	}
	static void puts(long[] ary){
		for(int i=0; i<ary.length-1; i++){
			System.out.printf("%d ",ary[i]);
		}
		System.out.println(ary[ary.length-1]);
	}
	static void tblSort(int[][] tbl){
		Arrays.sort(tbl, new Comparator<int[]>(){
			@Override
			public int compare(int[] a, int[] b){
				if(a[0]==b[0]){
					return b[1]-a[1];
				}else{
					return b[0]-a[0];
				}
			}
		});
	}
}
//  [java]
import java.util.Scanner;

public class Main {

	static Scanner scanner;
	public static void main(String[] args) {
	    scanner = new Scanner(System.in);

	    int a= gi();
	    int b= gi();
	    int c= gi();

        //System.out.print(aubstring(0,1));
        if (a<=c&&c<=b) {
        	System.out.print("Yes");
        }else{
        	System.out.print("No");
        }

	   
	}

	// 文字列として入力を取得
	public static String gs() {
		return scanner.next();
	}

	// intとして入力を取得
	public static int gi() {
		return Integer.parseInt(scanner.next());
	}

	// longとして入力を取得
	public static long gl() {
		return Long.parseLong(scanner.next());
	}
}
//  [cpp]

#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>

#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
#define m0(x) memset(x,0,sizeof(x))
#define fill(x,y) memset(x,y,sizeof(x))

using namespace std;


int dy[4] = { 0,0,1,-1 };
int dx[4] = { 1,-1,0,0 };
int dxx[8] = { 0,0,1,1,1,-1,-1,-1 };
int dyy[8] = { 1,-1,0,1,-1,0,1,-1 };


ll m = 1000000007;

const int MOD = 1000000007;

ll gcd(ll x, ll y) {
	ll m = max(x, y), n = min(x, y);
	if (m%n == 0)return n;
	else return gcd(m%n, n);
}
ll lcm(ll x, ll y) {
	return x / gcd(x, y)*y;
}

ll myPow(ll x, ll n, ll m) {
	if (n == 0)
		return 1;
	if (n % 2 == 0)
		return myPow(x * x % m, n / 2, m);
	else
		return x * myPow(x, n - 1, m) % m;
}



long long nCr(int n, int r) {
	if (r > n / 2) r = n - r; // because C(n, r) == C(n, n - r)
	long long ans = 1;
	int i;

	for (i = 1; i <= r; i++) {
		ans *= n - r + i;
		ans /= i;
	}

	return ans;
}


int main() {
	int A, B, C;
	cin >> A >> B >> C;
	bool ok = false;
	REP(i, 1000000000) {
		if (C >= A && C <= B)ok = true;
	}
	if (ok)cout << "Yes" << endl;
	else cout << "No" << endl;
}
//  [cpp]

#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>

#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
#define m0(x) memset(x,0,sizeof(x))
#define fill(x,y) memset(x,y,sizeof(x))

using namespace std;


int dy[4] = { 0,0,1,-1 };
int dx[4] = { 1,-1,0,0 };
int dxx[8] = { 0,0,1,1,1,-1,-1,-1 };
int dyy[8] = { 1,-1,0,1,-1,0,1,-1 };


ll m = 1000000007;

const int MOD = 1000000007;

ll gcd(ll x, ll y) {
	ll m = max(x, y), n = min(x, y);
	if (m%n == 0)return n;
	else return gcd(m%n, n);
}
ll lcm(ll x, ll y) {
	return x / gcd(x, y)*y;
}

ll myPow(ll x, ll n, ll m) {
	if (n == 0)
		return 1;
	if (n % 2 == 0)
		return myPow(x * x % m, n / 2, m);
	else
		return x * myPow(x, n - 1, m) % m;
}



long long nCr(int n, int r) {
	if (r > n / 2) r = n - r; // because C(n, r) == C(n, n - r)
	long long ans = 1;
	int i;

	for (i = 1; i <= r; i++) {
		ans *= n - r + i;
		ans /= i;
	}

	return ans;
}

int x[10000];
int main() {
	int A, B, C;
	cin >> A >> B >> C;
	bool ok = false;

	REP(i, 1000000000) {
		x[0] = i;
		ll ans = i % 57;
		if (C >= A && C <= B)ok = true;
	}
	if (ok)cout << "Yes" << endl;
	else cout << "No" << endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
	srand((unsigned)time(NULL));
	cin >> a >> b >> c; vector<int> v(rand() % 2000000 + 63000000);
	cout << (a <= c && c <= b ? "Yes" : "No") << endl;
	return 0;
}
//  [c]
# include"stdio.h"
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");
}
//  [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;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

#define rep(i, n) for(int i=0; i<(n); ++i)
#define max  200001

//qsort(str, n, sizeof(int), up_comp);
int up_comp(const void *a, const void *b){return *(int*)a - *(int*)b;}
int down_comp(const void *a, const void *b){return *(int*)b - *(int*)a;}
int int_sort( const void * a , const void * b ) {return strcmp(( char * )a , ( char * )b );}
int count_digit(int a){int i=0;while(a!=0){a=a/10;i++;}return i;}
int euclid( int a, int b ){int temp;if(a<b){temp=a;a=b;b=temp;}if(b<1)return -1;if(a%b==0) return b;return euclid(b,a%b);}

int main(void){
 
    int a, b, c;
    
    scanf("%d%d%d", &a, &b, &c);
    
    if (c>=a&&c<=b) {
        printf("Yes");
    } else {
        printf("No");
    }
    
    return 0;
}
//  [javascript]
"use strict";
// inputに入力データ全体が入る
const main = (input) => {
  const [a, b, c] = input.trim().split(" ").map(Number);
  return a <= c && c <= b ? "Yes" : "No";
};

// ※この行以降は編集しない (標準入力から一度に読み込みMainを呼び出します)
console.log(main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [javascript]
'use strict'

function main(input) {
  input = input.split(' ').map(v => ~~v)

  let ans = 'No'
  if (input[0] <= input[2] && input[2] <= input[1]) {
    ans = 'Yes'
  }

  console.log(ans)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
'use strict';

let abc = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(Number);

console.log((abc[0] <= abc[2] && abc[1] >= abc[2]) ? 'Yes' : '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 (
  "fmt"
)

func main() {
  var a, b, c int
  
  fmt.Scanf("%d %d %d", &a, &b, &c)
  
  ans := "Yes"
  if c < a {
    ans = "No"
  }
  if c > b {
    ans = "No"
  }
  
  fmt.Printf("%s", ans)
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - Between Two Integers
	var A, B, C int
	fmt.Scanf("%d %d %d", &A, &B, &C)

	if C >= A && C <= B {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [ruby]
a, b, c = gets().chomp.split("\s").map{|x| x.to_i}

puts a <= c && c <= b ? 'Yes' : 'No'
//  [ruby]
a, b, c = gets.split.map &:to_i
puts c >= a && c <= b ? :Yes: :No
//  [ruby]
a, b, c = gets.split.map(&:to_i)
puts a <= c && b >= c ? "Yes" : "No"
//  [rust]
use proconio::input;

fn main() {
    input! {
        a: i32,
        b: i32,
        c: i32,
    };
    let ans = (a..=b).contains(&c);
    println!("{}", if ans { "Yes" } else { "No" });
}
//  [rust]
use proconio::input;

fn main() {
  
  let mut _a : i128 ;
  let mut _b : i128 ;
  let mut _c : i128 ;
  

    input! {
     
      mut a : i128,
      mut b : i128,
      mut c : i128,

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

   }

}
//  [rust]
fn main() {
	proconio::input!{
		a: isize,
		b: isize,
		c: isize,
	}

	if a <= c && c <= b {
		println!("Yes");
	}
	else {
		println!("No");
	}
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const [A, B, C] = input[0].map(Number);

  return C >= A && C <= B ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [a, b, c] = stdin
  .split('\n')[0]
  .split(' ')
  .map(Number)

console.log(c >= a && c <= b ? 'Yes' : 'No')
//  [python]
import numpy as np
a = [int(i) for i in list(input().split())]
b = int((a[0]*(a[0]-1) +a[1]*(a[1]-1))/2)

print(b)
//  [python]
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
n,m = map(int,input().split())
ans = ((m+n) * (m+n-1))//2
kisu = (n *(n-1))//2
gusu = (m*(m-1))//2
kigu = ans - kisu - gusu

print(kisu+gusu)
//  [python]
from scipy.misc import comb
n, m = [int(x) for x in input().split()]



print(int(comb(n, 2, exact=True) + comb(m, 2, exact=True)))
//  [java]


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

/**
 * for (int i = 0; i < N; i++) {}
 * System.out.println();
 * HashMap<Integer, Integer> hm = new HashMap<>();
 * int[] s = new int[M];
 * ArrayDeque<Integer> deq = new ArrayDeque<>();
 *
 */
public class Main implements Runnable { //クラス名はMain1

	public static void main(String[] args) {
		Thread.setDefaultUncaughtExceptionHandler((t, e) -> System.exit(1));
		new Thread(null, new Main(), "", 1024 * 1024 * 1024).start(); //16MBスタックを確保して実行
	}

	public void run() {
		FastScannerMain1 sc = new FastScannerMain1(System.in);

		try {
			//String S = sc.nextLine().trim();
			int N = sc.nextInt();
			int M = sc.nextInt();
			//int[] a = new int[N];
			//long l = sc.nextLong();
			//ArrayList<Integer> arr = new ArrayList<Integer>();
			//for (int i = 0; i < N; i++) {}

			long ans1 = 0;
			long ans2 = 0;
			if (N >= 2) {
				ans1 = calcCombination(N, 2);
			}
			if (M > 2) {
				ans2 = calcCombination(M, 2);
			}

			System.out.println(ans1 + ans2);

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	long calcCombination(int n, int m) {
		if (n < m || m < 0) {
			throw new IllegalArgumentException("引数の値が不正です ( n : " + n + ", m : " + m + ")");
		}
		long c = 1;
		m = (n - m < m ? n - m : m);
		for (int ns = n - m + 1, ms = 1; ms <= m; ns++, ms++) {
			c *= ns;
			c /= ms;
		}
		return c;
	}
}

//高速なScanner
class FastScannerMain1 {
	private BufferedReader reader = null;
	private StringTokenizer tokenizer = null;

	public FastScannerMain1(InputStream in) {
		reader = new BufferedReader(new InputStreamReader(in));
		tokenizer = null;
	}

	public String next() {
		if (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public String nextLine() {
		if (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				return reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken("\n");
	}

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

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

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

	public int[] nextIntArray(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public long[] nextLongArray(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}
}
//  [java]
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();
		sc.close();

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

		print(answer);
	}

	public static void print(Object obj) {
		System.out.println(obj);
	}
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for( int i = 0 ; i < n ; i++ )
typedef long long ll ;
	const int MAX = 1e7;
const int MOD = 1000000007;

long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++){
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}

// 二項係数計算
long long COM(int n, int k){
  if (n < k) return 0;
  if (n < 0 || k < 0) return 0;
  return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
  COMinit();
  int N , M ;
  cin >> N >> M ;
  int A = 0 , B = 0 ;
  if(N >= 2 )A = COM(N,2) ;
  if(M >= 2) B = COM(M,2) ;
  cout << A + B << endl ;
}
//  [c]
#include <stdio.h>
 
int main()
{
	int a;
	int b;
	long long c;
	
	scanf("%d%d%", &a, &b);
	if (a == 1 && b == 1)
		printf("0");
	else 
    {
		if (a >= 2)
        {
          c = (a * (a - 1))/2;
        }
      if (b >= 2)
      {
        c += (b * (b - 1))/2;
      }
      printf("%d", c);
    }
    return 0;
}
//  [c]
#include<stdio.h>

int main(void){

  int n,m,sum;
  scanf("%d %d",&n,&m);
  sum=n+m;

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


  return 0;
}
//  [javascript]
function Main(n){n=n.split(" ");const o=Number(n[0]),c=Number(n[1]);console.log((o*(o-1)+c*(c-1))/2)} Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
"use strict";

const main = (input) => {
    const spi = input.split('\n');
    const [n, m] = spi[0].split(' ').map(e => Number(e));
    console.log(n*(n-1)/2 + m*(m-1)/2);
};

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

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

var sc = bufio.NewScanner(os.Stdin)
var buff []byte

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buff, bufio.MaxScanTokenSize*1024)
	log.SetFlags(log.Lshortfile)
}

type Combination struct {
	max, mod int
	fact     []int
	factInv  []int
	inv      []int
}

func NewCombination() *Combination {
	c := &Combination{}
	c.max = 200010
	c.mod = int(1e9) + 7
	c.fact = make([]int, c.max)
	c.factInv = make([]int, c.max)
	c.inv = make([]int, c.max)
	return c
}

func (c *Combination) build() {
	c.inv[1], c.fact[0], c.factInv[0] = 1, 1, 1
	var i int
	for i = 2; i < c.max; i++ {
		c.inv[i] = c.inv[c.mod%i] * (c.mod - c.mod/i) % c.mod
	}
	for i = 1; i < c.max; i++ {
		c.fact[i] = c.fact[i-1] * i % c.mod
		c.factInv[i] = c.factInv[i-1] * c.inv[i] % c.mod
	}
}

func (c *Combination) c(n, k int) int {
	if c.inv[0] == 0 {
		c.build()
	}
	if n < 0 || k < 0 || n < k {
		return 0
	}
	return c.fact[n] * c.factInv[k] % c.mod * c.factInv[n-k] % c.mod
}

func (c *Combination) p(n, k int) int {
	if k < 0 || k > n {
		return 0
	}
	return c.fact[n] * c.factInv[n-k] % c.mod
}

func (c *Combination) h(n, k int) int {
	if n == 0 && k == 0 {
		return 1
	}
	return c.c(n+k-1, k)
}

func main() {
	N := nextInt()
	M := nextInt()
	ans := 0
	cmb := NewCombination()
	cmb.build()
	if M > 0 {
		ans += cmb.c(M, 2)
	}
	if N > 0 {
		ans += cmb.c(N, 2)
	}
	fmt.Println(ans)
}

func nextString() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

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

var dy = []int{0, 1, 0, -1}
var dx = []int{1, 0, -1, 0}
var MAX = math.MaxInt32

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
}

type Pair struct {
	a, b int
}

type Pairs []Pair

func (p Pairs) Len() int {
	return len(p)
}
func (p Pairs) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

func (p Pairs) Less(i, j int) bool {
	if p[i].a == p[j].a {
		return p[i].b < p[j].b
	}
	return p[i].a < p[j].a
}
//  [go]
package main

import (
	"fmt"
)

func answer159A(m int, n int) int {
	evenPairs := m * (m - 1) / 2
	oddPairs := n * (n - 1) / 2

	return evenPairs + oddPairs
}


func main() {
	var m, n int
	fmt.Scanf("%d %d", &m, &n)
	
	fmt.Println(answer159A(m, n))
}
//  [ruby]
require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

N, M = get_ints

nx = (N * (N-1)) / 2
mx = (M * (M-1)) / 2

puts nx + mx
//  [ruby]
n,m = gets.chomp.split(" ").map(&:to_i)

puts n * (n-1) / 2 + m * (m-1) / 2
//  [ruby]
N, M = gets.split.map(&:to_i)
p (N*(N-1) + M*(M-1))/2
//  [rust]
use text_io::*;
use std::collections::HashMap;
use std::process::exit;

fn main() {
    let k:usize = read!();
    let n:usize = read!();
    println!("{}",(k*k-k+n*n-n)/2);
}
//  [swift]
import Foundation

let input_line = readLine()!
let array: [String] = input_line.componentsSeparatedByString(" ")
let even = Int(array[0])!
let odd = Int(array[1])!
var count = 0

// 偶数+偶数の数
if even > 1 {
  count += even * (even-1) / 2
}

// 奇数+奇数の数
if odd > 1 {
  count += odd * (odd-1) / 2
}

print(count)
//  [swift]
import Foundation

/*
// 1
let N = Int(readLine()!)!

// 1 2
let split = readLine()!.componentsSeparatedByString(" ")
let N = Int(split[0])!
let S = Int(split[1])!

// 1 2 3 4 5
let array = readLine()!.componentsSeparatedByString(" ").map { Int($0)! }
*/

let split = readLine()!.componentsSeparatedByString(" ")
let N = Int(split[0])!
let M = Int(split[1])!

var n = 0
var m = 0
for i in 0..<N {
  n += i
}

for i in 0..<M {
  m += i
}

if N <= 1 { n = 0 }
if M <= 1 { m = 0 }

print(n + m)
//  [swift]
import Foundation

let arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}
let a=arr[0]
let b=arr[1]
var c=0
if a > 1 {
  for i in 0..<a {
    c+=i
}
}
if b > 1 {
    for i in 0..<b {
    c+=i
}
}
 
print(c)
//  [python]
import numpy as np


n = int(input())
minlim = 10**15
for i in range(5):
    lim = int(input())
    if lim < minlim:
        minlim = lim

if minlim < n:
    if n % minlim == 0:
        print(n//minlim + 4)
    else:
        print(n//minlim + 5)
else:
    print(5)
//  [python]
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

def time_to_zero(n, carry):
    ans = 0
    amari = 0
    if n % carry:
        amari = 1
    return n // carry + amari

def main():
    N = I()
    l = []
    ans = 0
    for i in range(5):
        al = I()
        l.append(al)
    A, B, C, D, E = l
    m = min(l)
    minute = 0
    if N % m != 0:
        minute += 1
    minute += N // m
    minute += 4
    print(minute)
    # city_capa = N
    # prev_tr_capa = A
    # for tr_capa, next_tr_capa in zip(l, l[1:]+[0]):
    #     t = time_to_zero(city_capa, tr_capa)
    #     city_capa = city_capa - (t-1) * min(tr_capa, next_tr_capa)
    #     ans += t
    # print(ans)
main()
//  [python]
# -*- coding: utf-8 -*-
import sys
import numpy as np

def get_num():
    return int(input())


def get_nums(n):
    res = [0 for _ in range(n)]
    for i in range(n):
        res[i] = int(input())
    return res


def get_numbers():
    return map(int, input().split())


n = get_num()
costs = get_nums(5)

max_time = 0
for cost in costs:
    max_time = max(max_time, int(np.ceil(n / cost)))

print(max_time + 4)
//  [java]
import java.util.*;

public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		long N = sc.nextLong();
		long A = sc.nextLong();
		long B = sc.nextLong();
		long C = sc.nextLong();
		long D = sc.nextLong();
		long E = sc.nextLong();

		List<Long> timeList = Arrays.asList(A, B, C, D, E);
		long minTime = timeList.stream()
                .min((a, b) -> a.compareTo(b)).get();
		int minIndex = timeList.indexOf(minTime);


		long time = N/minTime;
		if(N%minTime != 0){
			time++;
		}

		time += 5- (minIndex+1) + minIndex;

		System.out.println(time);


	}


}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.stream.Stream;
import java.util.Collection;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.ArrayList;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author teiwa
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long N = in.nextLong();
            List<Long> passengerNum = new ArrayList<>();
            for (int i = 0; i < 5; i++) {
                passengerNum.add(in.nextLong());
            }

            List<Long> sortedPassengerNum = passengerNum.stream().sorted().collect(Collectors.toList());

            Long min = sortedPassengerNum.get(0);

            out.println((N - 1) / min + 5);
        }

    }
}
//  [java]
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)) {
			long n = scanner.nextLong();
			scanner.nextLine();
			long min = IntStream.range(0, 5).mapToLong(i -> {
				long number = scanner.nextLong();
				scanner.nextLine();
				return number;
			}).min().getAsLong();
			System.out.println((n - 1) / min + 5);
		}
	}
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

#define INF INT64_MAX
#define MAX 5

long long N;
long long a[MAX];

int main() {
	cin >> N;
	cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];

	long long mi = INF;
	for( int i = 0; i < MAX; i++ ) {
		mi = min( mi, a[i] );
	}
	long long d = N / mi;
	if( N % mi ) {
		d++;
	}
	long long ans = 4 + d;

	cout << ans << endl;

	return 0;
}
//  [c]
//abc123_c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <stdbool.h>
#define ll long long
#define rep(a,b,c) for(ll i=a;i<b;i+=c)

ll N,A,B,C,D,E;

ll min(ll a, ll b, ll c, ll d, ll e){
    ll x[5]={a,b,c,d,e};
    ll min=1000000000000000;
    for(int i=0;i<5;i++){
        if(x[i]<min){
            min=x[i];
        }
    }
    return min;
}

int main(void){
    scanf("%lld %lld %lld %lld %lld %lld",&N,&A,&B,&C,&D,&E);
    ll lowspeed=min(A,B,C,D,E);
    ll ans;
    if(N<=lowspeed){
        printf("5\n");
    }else {
        if(N%lowspeed==0){
            ans=(N/lowspeed)+4;
        }else {
            ans=(N/lowspeed)+5;
        }
        printf("%lld\n",ans);
    }
    return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
#define MOD 1000000007
#define rep(i,l,r) for(ll i=l;i<r;i++)

typedef long long ll;

int main() {
    ll n, a;
    scanf("%lld",&n);
    ll min = 10000000000000000;
    rep(i, 0, 5) {
        scanf("%lld", &a);
        min = (min < a) ? min : a;
    }
    printf("%lld", (n - 1) / min + 5);

    return 0;
}