jiahuimbzuai/CoQuIR huggingface dataset:
//  [python]
import sys
import math
import copy
import heapq
import random
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter

# sys.setrecursionlimit(1000000)

# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = float("inf")
MOD = 10 ** 9 + 7
divide = lambda x: pow(x, MOD - 2, MOD)


def nck(n, k, kaijyo):
    return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD


def npk(n, k, kaijyo):
    if k == 0 or k == n:
        return n % MOD
    return (kaijyo[n] * divide(kaijyo[n - k])) % MOD


def fact_and_inv(SIZE):
    inv = [0] * SIZE  # inv[j] = j^{-1} mod MOD
    fac = [0] * SIZE  # fac[j] = j! mod MOD
    finv = [0] * SIZE  # finv[j] = (j!)^{-1} mod MOD
    inv[1] = 1
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    for i in range(2, SIZE):
        inv[i] = MOD - (MOD // i) * inv[MOD % i] % MOD
        fac[i] = fac[i - 1] * i % MOD
        finv[i] = finv[i - 1] * inv[i] % MOD

    return fac, finv


def renritsu(A, Y):
    # example 2x + y = 3, x + 3y = 4
    # A = [[2,1], [1,3]])
    # Y = [[3],[4]] または [3,4]
    A = np.matrix(A)
    Y = np.matrix(Y)
    Y = np.reshape(Y, (-1, 1))
    X = np.linalg.solve(A, Y)

    # [1.0, 1.0]
    return X.flatten().tolist()[0]


class TwoDimGrid:
    # 2次元座標 -> 1次元
    def __init__(self, h, w, wall="#"):
        self.h = h
        self.w = w
        self.size = (h + 2) * (w + 2)
        self.wall = wall
        self.get_grid()
        # self.init_cost()

    def get_grid(self):
        grid = [self.wall * (self.w + 2)]
        for i in range(self.h):
            grid.append(self.wall + getS() + self.wall)

        grid.append(self.wall * (self.w + 2))
        self.grid = grid

    def init_cost(self):
        self.cost = [INF] * self.size

    def pos(self, x, y):
        # 壁も含めて0-indexed 元々の座標だけ考えると1-indexed
        return y * (self.w + 2) + x

    def getgrid(self, x, y):
        return self.grid[y][x]

    def get(self, x, y):
        return self.cost[self.pos(x, y)]

    def set(self, x, y, v):
        self.cost[self.pos(x, y)] = v
        return

    def show(self):
        for i in range(self.h + 2):
            print(self.cost[(self.w + 2) * i:(self.w + 2) * (i + 1)])

    def showsome(self, tgt):
        for t in tgt:
            print(t)
        return

    def showsomejoin(self, tgt):
        for t in tgt:
            print("".join(t))
        return

    def search(self):
        grid = self.grid
        move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        move_eight = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
        # for i in range(1, self.h+1):
        #     for j in range(1, self.w+1):
        #         cx, cy = j, i
        #         for dx, dy in move_eight:
        #             nx, ny = dx + cx, dy + cy


def solve():
   d, t,s  = getList()
   if s * t >= d:
       print("Yes")
   else:
       print("No")

if __name__ == "__main__":
    # main()
    solve()
//  [java]
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        Scanner kb = new Scanner(System.in);

        double D = kb.nextDouble();
        double S = kb.nextDouble();
        double T = kb.nextDouble();

        if(D/S <= T)
            System.out.println("Yes");
        else
            System.out.println("No");

    }
}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int distance = Integer.parseInt(scan.next());
    int time = Integer.parseInt(scan.next());
    int speed = Integer.parseInt(scan.next());

    String result;
    if (distance > time * speed) {
      result = "No";
    } else {
      result = "Yes";
    }

    PrintWriter out = new PrintWriter(System.out);
    out.println(result);
    out.flush();
  }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define pi 2*asin(1.0)
#define MAX 10000000
#define MOD 1000000007
 
 
vector<long> fac(MAX);
vector<long> finv(MAX);
vector<long> inv(MAX);
 
//template functions
/////////////////////////
void Cominit(){
  fac.at(0)=fac.at(1)=1;
  finv.at(0)=finv.at(1)=1;
  inv.at(1)=1;
  for(long i=2;i<MAX;i++){
      fac.at(i)=(fac.at(i-1)*i)%MOD;
      inv.at(i)=MOD-inv.at(MOD%i)*(MOD/i)%MOD;
      finv.at(i)=finv.at(i-1)*inv.at(i)%MOD;
  }
}

long facComb(long N,long M){// nCm%
if(N<M) return 0;
if(N<0||M<0) return 0;
return fac.at(N)*(finv.at(M)*finv.at(N-M)%MOD)%MOD;
}

long Comb(long N,long M){// nCm
long ans=1;
for(long i=N;i>N-M;i--){
    ans=ans*i;
}
for(long i=M;i>0;i--){
    ans=ans/i;
}
return ans;
}

long Perm(long N,long M){// nPm
long ans=1;
for(long i=N;i>N-M;i--){
    ans=ans*i;
}
return ans;
}

long GCM(long A,long B){
            long W,r;
    if(A<B){

        W=B;
        B=A;
        A=W;
    }
    while(A%B!=0){
        r=A%B;
        A=B;
        B=r;
    }
    return B;
}
long LCM(long A,long B){
    return (A*B)/GCM(A,B);
}

long upDiv(long a,long b){
  return (a+b-1)/b;
}

/////////////////////////


//Answer


int main() {

long T,S,D;
cin>>D>>T>>S;

if(D>T*S){
    cout<<"No"<<endl;
}else{
    cout<<"Yes"<<endl;
}
}
//  [c]
#include <stdio.h>

int main(void) {
  float d,t,s;
  scanf("%f %f %f",&d,&t,&s);
  float g=d/s;
  if(t>=(d/s))
  printf("Yes\n");
  else printf("No\n");
  return 0;
}
//  [c]
#include <stdio.h>
int main(void)
{
    int d,t,s;
    scanf("%d %d %d", &d,&t,&s);
    double time = (double)d / s;
    if(time > t){
        printf("No");
    }
    else{
        printf("Yes");
    }
    return 0;

}
//  [c]
#include <stdio.h>

#define MAX 10000

int check_spec(double value);
 
int main (void) {
    double distance;
    double speed;
    double time;
    scanf ("%lf %lf %lf", &distance, &time, &speed);

    if (check_spec(distance) == 0 || check_spec(time) == 0 || check_spec(speed) == 0) {
        return 0;
    }
 
    if (distance/speed * 1.0 > time) {
        printf("No\n");
    } else {
        printf("Yes\n");
    }
    return 0;
}

int check_spec(double value) {
    if (value < 0 || value > MAX) {
        return 0;
    }

    return 1;
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  var input = input.split(" ");
  // 距離(m)
  var d = parseInt(input[0], 10);
  // 時間(m)
  var t = parseInt(input[1], 10);
  // 速度(m/m)
  var s = parseInt(input[2], 10);
  
  var validate = (val) => {
      return 1 <= val && val <= 10000;
  };
  
  if (!validate(d) || !validate(t) || !validate(s)) {
    console.log("No");
    return;
  }
  
  // 速さ * 時間 = 距離
  var result = s * t >= d;

  console.log(result ? "Yes" : "No");
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const [d, t, s] = input.trim().split(' ').map(x => parseInt(x))
  if (s*t >= d) {
    console.log('Yes')
  } else {
    console.log('No')
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const data = input.split(' ');
  return (parseInt(data[0]) / parseInt(data[2]) <= parseInt(data[1])) ? 'Yes' : 'No';
}

async function readline() {
  return new Promise((resolve, reject) => {
    const reader = require('readline').createInterface({
      input: process.stdin,
      output: process.stdout
    });
    reader.on('line', line => {
      resolve(line)
    });
  });
}

(async () => {
  console.log(Main(await readline()));
})();
//  [go]
package main

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

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

	sc.Scan()
	a := strings.Split(sc.Text(), " ")
	D, _ := strconv.Atoi(a[0])
	T, _ := strconv.Atoi(a[1])
	S, _ := strconv.Atoi(a[2])

	if S*T >= D {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

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

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

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

func nextFloat64() float64 {
	sc.Scan()
	f, err := strconv.ParseFloat(sc.Text(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

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.MaxInt64

func maxInt(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r < a[i] {
			r = a[i]
		}
	}
	return r
}
func minInt(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 absInt(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
}

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

func main() {
	D := nextInt()
	T := nextInt()
	S := nextInt()
	if S*T >= D {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [ruby]
require 'bigdecimal/util'
d, t, s = gets.split.map &:to_i
if d / s.to_d <= t
  puts 'Yes'
else
  puts 'No'
end
//  [ruby]
d, t, s = gets.chomp.split(" ").map(&:to_i)
if (t * s >= d)
    puts "Yes"
else
    puts "No"
end
//  [ruby]
D, T, S = gets.split.map(&:to_i)

puts T * S >= D ? 'Yes' : 'No'
//  [swift]
// 🐋💭
import Foundation

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

func readInt() -> Int {
    return Int(readLine()!)!
}

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

func readDouble() -> Double{
    return Double(readLine()!)!
}

func readLines() -> [String] {
    return readLine()!.map { String($0) }
}
///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///最大公約数を返す
func gcd(_ array: [Int]) -> Int {
    var value = array[0]
    if array.count > 1 {
        for i in 1..<array.count {
            value = gcd(value, array[i])
        }
    }
    return value
}

///最小公倍数を返す
func lcm(_ m:Int, _ n:Int) -> Int {
    return m * n / gcd(m, n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {
    
    mutating func remove(_ element: Element) {
        _ = firstIndex(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt
    
    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2
        
        if Int(ary[mid])! < key {
            left = mid
            
        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }
    
    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}
// https://algo-logic.info/divisor/
/// 約数の配列を返す
func divisor(_ n:Int) -> [Int] {
    var ret = [Int]()
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            ret.append(i)
            if i * i != n {
                ret.append(n / i)
            }
        }
        i += 1
    }
    return ret.sorted()
}

func main() {
    let input = readInts()
    let(D, T, S) = (input[0], input[1], input[2])
    //＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿入力
    
    print(T * S < D ? "No": "Yes")
    
}
main()
//  [swift]
import Foundation

let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
let a = Int(split[0])!
let b = Int(split[1])!
let c = Int(split[2])!

if (c * b >= a) {
    print("Yes")
}else{
    print("No")
}
//  [swift]
import Foundation

let args = readLine()!.components(separatedBy: " ")
let D = Double(args[0])!
let T = Double(args[1])!
let S = Double(args[2])!
if (D / S <= T) {
  print("Yes")
} else {
  print("No")
}
//  [typescript]
import { readFileSync } from 'fs'
import { reverse } from 'dns'
import { start } from 'repl'
 
let lines: string[] = [];
const reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});
 
reader.on('line', function (line: string) {
    lines.push(line);
});
reader.on('close', function () {
    let [D, T, S] = lines[0].split(' ').map( _ => parseInt(_))
 
    let ans = D <= T * S ? "Yes" : "No"
    console.log(ans)
});
//  [typescript]
import { readFileSync } from 'fs'
import { reverse } from 'dns'
import { start } from 'repl'

function main(input: string[]) {
  let [D, T, S] = input[0].split(' ').map( _ => parseInt(_))

  let ans = D <= T * S ? "Yes" : "No"
  console.log(ans)
}

let lines: string[] = [];
const reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', function (line: string) {
  lines.push(line);
});
reader.on('close', function () {
  main(lines)
});
//  [typescript]
import * as fs from "fs";

const input = fs.readFileSync("/dev/stdin", "utf8").split(" ");

const D = +input[0];
const T = +input[1];
const S = +input[2];

const ans = T * S >= D ? "Yes" : "No";

console.log(ans);
//  [python]
# coding : utf-8

import numpy as np

A = input()

if(A[0]!=A[1] and A[0]!=A[2] and A[1]!=A[2]):
	print("Yes")
else:
	print("No")
//  [python]
S = list(input())
S.sort()
if "".join(S)=="abc":
    print("Yes")
else:
    print("No")
//  [python]
# -*- coding: utf-8 -*-
import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import numpy as np
import statistics
from statistics import mean, median,variance,stdev
import math

def main():
	S = input()
	
	ans = [-1 for _ in range(3)]
	
	for i in range(3):
		if S[i] == "a":
			ans[0] = 1
		elif S[i] == "b":
			ans[1] = 1
		elif S[i] == "c":
			ans[2] = 1
	
	if ans[0] == ans[1] == ans[2] == 1:
		print("Yes")
	else:
		print("No")
			
	
if __name__ == "__main__":
	main()
//  [java]
import java.util.Scanner;

class Main {

    private static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        String s = sc.next();
        if (s.contains("a") && s.contains("b") && s.contains("c")) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}
//  [java]
import java.util.Scanner;

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

        String S = sc.next();

        System.out.println(solve(S) ? "Yes" : "No");

        sc.close();
    }

    static boolean solve(String S) {
        return S.chars().distinct().count() == 3;
    }
}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.stream.IntStream;
import java.io.IOException;
import java.util.InputMismatchException;
import java.util.stream.Collectors;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.stream.Stream;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

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

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            String s = in.nextString();
            String sortedS = String.join("", s.chars().sorted().mapToObj(c -> "" + (char) c).collect(Collectors.toCollection(ArrayList::new)));
            out.println("abc".equals(sortedS) ? "Yes" : "No");
        }

    }

    static class InputReader {
        BufferedReader br;
        StringTokenizer st;

        public InputReader(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
            st = new StringTokenizer("");
        }

        public String nextString() {
            while (!st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine(), " ");
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
            }
            return st.nextToken();
        }

    }
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main()

{
    string s;
    cin>>s;
    int a=0,b=0,c=0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i]=='a') a++;
        else if(s[i]=='b') b++;
        else c++;
    }
    if(a==1 && b==1 && c==1) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define all(v) v.begin(), v.end()
#define mem(arr) memset(arr, 0, sizeof(arr))
#define ff first
#define ss second
#define int long long int
const int MOD = 1e9 + 7;
const int INF = 1e18;
const int N = 1e6 + 1;
vector<int> g[N];
vector<int> vis(N);
void solve(){
    string s;
    cin >> s;
    sort(all(s));
    cout << (s == "abc" ? "Yes\n" : "No\n");
}
int32_t main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int tc = 1;
    while(tc--){
        solve();
    }
}
//  [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 );
  string s;
  cin>>s;
  int sum=0;
  rep(i,3){
    sum+=s[i]-'a';
  }
  string ans="No";
  if(sum==3)ans="Yes";
  cout(ans);
  return 0;
}
//  [c]
#include <stdio.h>
int main(void)
{
  char p,q,r;
  int a=0,b=0,c=0;
  scanf("%s%s%s",&p,&q,&r);
  switch(p)
  {
    case 'a':
      a++;
      break;
    case 'b':
      b++;
      break;
    case 'c':
      c++;
      break;
  }
  switch(q)
  {
    case 'a':
      a++;
      break;
    case 'b':
      b++;
      break;
    case 'c':
      c++;
      break;
  }
  switch(r)
  {
    case 'a':
      a++;
      break;
    case 'b':
      b++;
      break;
    case 'c':
      c++;
      break;
  }
  if (a==1&&b==1&&c==1) printf("Yes\n");
  else printf("No\n");
}
//  [c]
#include <stdio.h>

int main()
{
	int a, b, c;
	char S[4];
	scanf("%s", S);
	a = S[0] - 'a';
	b = S[1] - 'a';
	c = S[2] - 'a';
	if (a * b * c == 0 && a + b + c == 3 && a * b + b * c + c * a == 2) printf("Yes\n");
	else printf("No\n");
	fflush(stdout);
	return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	char s[3];
	scanf("%s",s);
	if(s[0]==s[1]||s[0]==s[2]||s[1]==s[2]) printf("No\n");
	else printf("Yes\n");
	return 0;
}
//  [javascript]
function Main(s) {
  var a = 0, b = 0, c = 0;
  for(var i = 0; i < 3; i++){
    if(s[i] === "a")a = 1;
    if(s[i] === "b")b = 1;
    if(s[i] === "c")c = 1;
  }
  console.log(a + b + c === 3 ? "Yes" : "No");
}

Main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
function Main(input){
	input=input.split("\n");
	var n=input[0];
	var arr=[];
	for(var i=0;i<3;i=(i+1)|0){arr[n.charAt(i)]=true;}
	if(arr["a"]==true&&arr["b"]==true&&arr["c"]==true){console.log("Yes");}
	else{console.log("No");}
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

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

func main() {
	// Code for A - abc of ABC
	var S string
	fmt.Scanf("%s", &S)
	S = sortString(S)

	if S == "abc" {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
  "strings"
  "fmt"
)

func main() {
  var s string
  fmt.Scanf("%s", &s)
  
  ans := "Yes"
  if !strings.Contains(s, "a") {
    ans = "No"
  }
  if !strings.Contains(s, "b") {
    ans = "No"
  }
  if !strings.Contains(s, "c") {
    ans = "No"
  }
  fmt.Printf("%s\n", ans)
}
//  [ruby]
t = Time.now

ARRAY = "abc".split('')
S = gets.chomp.split('')

while Time.now - t < 1.9 do
    if ARRAY.shuffle == S
        puts "Yes"
        exit
    end
end

puts "No"
//  [ruby]
ARRAY = "abc".split('')
S = gets.chomp.split('')
t = Time.now

while Time.now - t < 1.5 do
    if ARRAY.shuffle[0, 3] == S
        puts "Yes"
        exit
    end
end

puts "No"
//  [ruby]
puts`dd`.sum==304?:Yes: :No
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
use proconio::input;
use proconio::fastout;
use proconio::marker::*;

fn type_of<T>(_: T) -> String{
    let a = std::any::type_name::<T>();
    return a.to_string();
}

#[fastout]
fn main() {
    input! {
        mut s:Chars,
    }
    
    s.sort();
    let s2:String=s.iter().collect();
    println!("{}",if s2=="abc"{"Yes"}else{"No"});
}
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_imports)]

use proconio::{input, fastout};
use proconio::marker::*;
use whiteread::parse_line;
use std::collections::*;
use num::*;
use superslice::*;

use itertools::Itertools;
use itertools_num::ItertoolsNum;

#[fastout]
fn main() {
    input!{
        s: Chars,
    }

    if s[0] == s[1] || s[1] == s[2] || s[2] == s[0]  {
        println!("No");
    } else {
        println!("Yes");
    }
    
}
//  [rust]
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::{Bytes, Chars};
#[allow(unused_imports)]
use std::cmp::{min, max};

fn main() {
	input! {
		mut cs: Chars,
	}

	cs.sort();
	let s: String = cs.into_iter().collect();

	if s == "abc" {
		println!("Yes");
	}
	else {
		println!("No");
	}
}
//  [typescript]
function Main(input) {
    let a = 0;
    let b = 0;
    let c = 0;
    for (let str of input) {
        if (str == 'a') a++;
        if (str == 'b') b++;
        if (str == 'c') c++;
    }
    if (a && b && c)
        console.log('Yes');
    else
        console.log('No');
}

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

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

const main = (input: string[][]) => {
  const S = input[0][0];

  return new Set(S).size === 3 ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
namespace Coder {
  class Scanner {
    private buffer: string = '';
    private stdinQueue: any = [];

    constructor() {
      process.stdin.resume();
      process.stdin.setEncoding('utf8');
      process.stdin.on(
        'data',
        (chunk): void => {
          this.buffer += chunk;
          while (this.stdinQueue.length > 0) {
            const i = this.buffer.indexOf('\n');
            if (i < 0) {
              break;
            }
            let line = this.buffer.substr(0, i);
            if (line.endsWith('\r')) {
              line = line.slice(0, -1);
            }
            this.buffer = this.buffer.substr(i + 1);
            this.stdinQueue.shift()(line);
          }
        },
      );
    }
    public getLine(): Promise<string> {
      return new Promise((resolve, reject) => {
        const i = this.buffer.indexOf('\n');
        if (i >= 0 && this.stdinQueue.length === 0) {
          let line = this.buffer.substr(0, i);
          if (line.endsWith('\r')) {
            line = line.slice(0, -1);
          }
          this.buffer = this.buffer.substr(i + 1);
          resolve(line);
        } else {
          this.stdinQueue.push(resolve);
        }
      });
    }

    public close(): void {
      process.stdin.pause();
    }
  }

  async function solve() {
    const sc = new Scanner();
    const S: string[] = (await sc.getLine()).split('');
    S.sort();
    if (S.join('') === 'abc') {
      console.log('Yes');
    } else {
      console.log('No');
    }

    sc.close();
  }
  solve();
}
//  [python]
from time import sleep

x = int(input())
a = int(input())
b = int(input())

ans = (x - a) % b

sleep(a * 0.002)

print(ans)
//  [python]
from time import sleep

x = int(input())
a = int(input())
b = int(input())

ans = (x - a) % b

sleep(b * 0.002)

print(ans)
//  [java]
import java.lang.String;
import java.lang.reflect.Array;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;


public class Main {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        x-= a;
        x-=(x/b)*b;
        System.out.println(x);


    }

}
//  [java]
import java.util.*;
public class Main{
  public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int kari=x-a;
    kari=kari%b;
    System.out.println(kari);
  }
}
//  [java]
import java.util.*;


public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        System.out.println((a-b)%c);
    }
}
//  [cpp]
#include <iostream>

using namespace std;

int main() {

	/* ----- 変数宣言 ----- */
	int x;
	int a;
	int b;
	
	int ans=0;


	/* ----- 入力 ----- */
	cin >> x;
	cin >> a;
	cin >> b;

	/* ----- 計算 ----- */
	x -= a;

	while (x >= b)	x -= b;

	ans = x;

	cout << ans << endl;
}
//  [cpp]
#include <bits/stdc++.h>
#define int long long
using namespace std;
#define mod 1000000007

bool vis[200005];
vector<int> vec[2000005], v1;
int child[2000005];
int parent[2000005];
int div1[100005];
int min_indx[200005];
int count1 = 0;
int height = 0;
int max_indx[200005];
void dfs(int node)
{

    vis[node] = 1;

    min_indx[count1] = node;
    max_indx[node] = min(max_indx[node], count1);
    count1++;

    //  count1++;
    child[node] = height++;
    for (int i = 0; i < vec[node].size(); i++)
    {
        if (!vis[vec[node][i]])
        {
            dfs(vec[node][i]);
            min_indx[count1] = node;
            max_indx[node] = min(max_indx[node], count1);
            count1++;
        }
    }
    height--;
}
int MAXN = 200005;
int LOGMAXN = (int)log2(200005) + 1;
int M[200005][60];
int ans[200005];
void fun(int a, int b, int c)
{
    //ll val = 1;

    while (a <= b)
    {
        ans[a] += c;
        int p = -a;
        a += (a & p);
    }
}
int find1(int a)
{
    int sum = 0;
    while (a != 0)
    {
        sum += ans[a];
        int p = -a;
        a -= (a & p);
    }
    return sum;
}
void process2(int A[], int N)
{
    int i, j;

    for (i = 0; i < N; i++)
        M[i][0] = i;
    for (j = 1; 1 << j <= N; j++)
        for (i = 0; i + (1 << j) - 1 < N; i++)
            if (find1(M[i][j - 1]) < find1(M[i + (1 << (j - 1))][j - 1]))
                M[i][j] = M[i][j - 1];
            else
                M[i][j] = M[i + (1 << (j - 1))][j - 1];
}

int32_t main()
{
    int x, a, b;
    cin >> x >> a >> b;
    cout << (x - a) % b << "\n";
    return 0;
}
//  [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 x,a,b;
  cin>>x>>a>>b;
  int ans=(x-a)%b;
  cout(ans);
  return 0;
}
//  [c]
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
long long a,b,c,d,e,f;
scanf("%lld %lld %lld",&c,&a,&b);
//if (abs(c-a)<=d || abs (b-a)<=d && abs (c-b)<=d)
/*if ((a*b)%2==0)
printf("Even");
else
printf("Odd");*/

if (c>=a) c=c-a;
printf("%lld",c%b);
//else printf("%lld",f);
}
//  [c]
#include <stdio.h>
int main ()
{
	int a,b,c,n,k;
	scanf("%d %d %d",&a,&b,&c);
	n=a-b;
	k=n%c;
	
	printf("%d\n",k);
	
	return 0;

}
//  [c]
#include <stdio.h>

int main()
{
	int X, A, B;
	scanf("%d", &X);
	scanf("%d", &A);
	scanf("%d", &B);
	printf("%d\n", (X - A) % B);
	fflush(stdout);
	return 0;
}
//  [javascript]

const Release = function () {
    const fs = require('fs');
    const stdin = function (text) {
        if (text) console.log(text);
        return fs.readFileSync('/dev/stdin', 'utf8');
    }
    return stdin;
};


const debug = false;

const stdin = debug ? Debug() : Release();
const input = stdin().split('\n').map(x => parseInt(x));

const X = input[0];
const A = input[1];
const B = input[2];

const c = (X - A) % B;
console.log(c);
//  [javascript]
const main = () => {
  const xab = getParams()
      , x = xab[0]
      , a = xab[1]
      , b = xab[2];
  console.log(solve(x, a, b));
};

const getParams = () =>
  getStdin().split('\n').map(Number);

const getStdin = () =>
  require('fs').readFileSync('/dev/stdin', 'utf8').trim();

const solve = (x, a, b) =>
  (x - a) % b;

main();
//  [javascript]
function Main(input) {
    var inp = input.split("\n");
    var X = parseInt(inp[0]);
    var A = parseInt(inp[1]);
    var B = parseInt(inp[2]);
    var nokori = (X - A) % B;
    console.log(nokori);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import "fmt"

func main() {
	var (
		x, a, b int
	)

	fmt.Scan(&x, &a, &b)

	fmt.Print((x - a) % b)

}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var x, a, b int
  fmt.Scanf("%d", &x)
  fmt.Scanf("%d", &a)
  fmt.Scanf("%d", &b)
  
  ans := (x - a) % b
  fmt.Printf("%d\n", ans)
}
//  [ruby]
a,b,c=`dd`.split.map(&:to_i)
p (a-b)%c
//  [ruby]
#!/usr/bin/env 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.chomp.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

X = get_int
A = get_int
B = get_int

x = X - A

puts x % B
//  [ruby]
puts  (gets.to_i - gets.to_i) % gets.to_i
//  [rust]
use proconio::input;
use proconio::marker::Chars;
fn main() {
    input!{
        x:usize,a:usize,b:usize
    };
    println!("{}",(x-a) % b);
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

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

#[fastout]
fn main() {
    input!{
        x: usize,
        a: usize,
        b: usize,
    }

    println!("{}", (x-a)%b);

}
//  [rust]
#![allow(unused_imports)]

use text_io::*;
use proconio::*;
use std::collections::*;
use std::process::exit;
use std::cmp::*;
use itertools::Itertools;

fn main() {
    input! {
    a:isize,
    b:isize,
    c:isize,
    }
    println!("{}",(a-b)%c)
}
//  [typescript]
import { readFileSync } from "fs";

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

const main = (input: string[][]) => {
  const X = Number(input[0][0]);
  const A = Number(input[1][0]);
  const B = Number(input[2][0]);

  return (X - A) % B;
};

console.log(main(read()));
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc087 {

    export class Program {

        constructor(private readonly args: string[][]) {
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            const [x]: number[] = this.args[0].map(Number);
//            const x: number = parseInt(this.args[0][0], 10);
            const a: number = parseInt(this.args[1][0], 10);
            const b: number = parseInt(this.args[2][0], 10);

            let wk: number = x - a;
            console.log(wk % b);

        }
    }
}

const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
const prg: AtCoder.abc087.Program = new AtCoder.abc087.Program(args);
prg.main();
//  [typescript]
const main = (input) => {
  input = input.split('\n');
  const X = parseInt(input[0], 10);
  const A = parseInt(input[1], 10);
  const B = parseInt(input[2], 10);
  
  console.log((X-A)%B);
  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
n=int(input())
a=list(map(int,input().split()))
print(max(a)-min(a))
//  [python]
N = int(input())
a = list(map(int, input().split()))

print(max(a) - min(a))
//  [python]
#064_B
n=input()
a=list(map(int,input().split()))
print(max(a)-min(a))
//  [python]
import numpy as np

if __name__=="__main__":
    N = int(input())
    a = input().split()
    a = list(map(int, a))
    a = np.sort(a)
    s = 0
    for i in range(len(a) - 1):
        s += (a[i+1] - a[i])

    print(s)
//  [python]
import numpy as np
 
n = int(input())
a = list(int(i) for i in input().split()) 
a.sort()
b = a[n - 1] - a[0]

print (b)
//  [python]
n = raw_input()
ais = map(int, raw_input().split())
print max(ais) - min(ais)
//  [java]
/**
 * @author Finn Lidbetter
 */
import java.util.*;
import java.io.*;
import java.awt.geom.*;

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

    int n = Integer.parseInt(br.readLine());
    int[] arr = new int[n];
    String[] s=  br.readLine().split(" ");
    for (int i=0; i<n; i++) {
      arr[i] = Integer.parseInt(s[i]);
    }
    Arrays.sort(arr);
    System.out.println(arr[n-1]-arr[0]);
  }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        try {
            // 標準入力
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            int n = Integer.parseInt(br.readLine());
            String strArr[] = br.readLine().split(" ");
            int min = Integer.parseInt(strArr[0]);
            int max = Integer.parseInt(strArr[0]);
            for (int i = 1; i < n; i++) {
                int tmp = Integer.parseInt(strArr[i]);
                if (tmp < min) {
                    min = tmp;
                }
                if (tmp > max) {
                    max = tmp;
                }
            }
            System.out.println(max - min);
       } catch (IOException e) {
            e.printStackTrace();
       }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import static java.lang.System.in;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        int N = Integer.parseInt(reader.readLine());
        String[] inputs = reader.readLine().split(" ");
        int min = 1000;
        int max = 0;
        for (int i = 0; i < N; i++) {
            int a = Integer.parseInt(inputs[i]);
            if (max < a) {
                max = a;
            }
            if (a < min) {
                min = a;
            }
        }
        System.out.println(max-min);

    }
}
//  [java]
import java.io.*;
import java.lang.*;
import java.util.*;
import java.math.*;

class Main{
	static int imax=Integer.MAX_VALUE;
	static long lmax=Long.MAX_VALUE;
	
	public static void main(String[] args) throws FileNotFoundException{
		
		Scanner sc=new Scanner(System.in);
		int n=readI(sc);
		int[] num=readlnI(sc," ");
		int mn=1000; int mx=0;
		for(int i=0;i<n; i++){
			if(mn>num[i]) mn=num[i];
			if(mx<num[i]) mx=num[i]; 
		}
		puts(mx-mn);
		}//main_end
	
	//utility
	static int readI(Scanner sc){
		return Integer.parseInt(sc.nextLine().trim());
	}
	static long readL(Scanner sc){
		return Long.parseLong(sc.nextLine().trim());
	}
	static String readS(Scanner sc){
		return sc.nextLine().trim();
	}
	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 String[] readlnS(Scanner sc, String dl){
		return sc.nextLine().trim().split(dl);
	}
	@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 bs(){
		System.out.println("");
	}
	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.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();
			int[] a = new int[n];
			int max = IntStream.range(0, n).map(i -> a[i] = scanner.nextInt()).max().getAsInt();
			System.out.println(max - Arrays.stream(a).min().getAsInt());
		}
	}
}
//  [java]
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        int N = scanner.nextInt();
        int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            a[i] = scanner.nextInt();
        }

        int max = Arrays.stream(a).boxed().max(Comparator.naturalOrder()).get();
        int min = Arrays.stream(a).boxed().min(Comparator.naturalOrder()).get();
        System.out.println(max - min);
    }

}
//  [cpp]
#include<cstdio>
#include<climits>
#include<algorithm>
using namespace std;
int main()
{
    int n,a[105];
    while(~scanf("%d",&n))
    {
        int MIN=INT_MAX,MAX=INT_MIN;
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
            MIN=min(MIN,a[i]);
            MAX=max(MAX,a[i]);
        }
        printf("%d\n",MAX-MIN);
    }
    return 0;
}
//  [cpp]
#include<stdio.h>
#include<string.h>
int main()
{
    int a,b[100],n,c,d;
    scanf("%d",&n);
    for(a=0;a<n;a++)
    {
     scanf("%d",&b[a]);
     if(a==0)
     {c=b[0];d=b[0];}
     if(b[a]>c) c=b[a];
     if(b[a]<d) d=b[a];
    }
    printf("%d\n",c-d);
    return 0;
}
//  [cpp]
#include<cstdio>
int main()
{
    int n,ma,mi,a;
    ma=0,mi=100000;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&a);
        if(a<mi) mi=a;
        if(ma<a) ma=a;
    }
    printf("%d\n",ma-mi);
    return 0;
}
//  [cpp]
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<iomanip>
#include <math.h>
using namespace std;
int main(){
    int n;
    cin>>n;
    vector<int>a(1000000);
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    sort(a.begin(),a.end(),greater<>());
    cout<<a[0]-a[n-1]<<endl;
    return 0;
}
//  [cpp]
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>

using namespace std;

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

int main(){
	int N; cin >> N;
	vector<int> a;
	
	REP(i,N){
		int n; cin >> n;
		a.push_back(n);
	}

	sort( a.begin(), a.end() );

	cout << a[N-1] - a[0] << endl;

	return 0;
}