jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#include<stdio.h>
#include<string.h>
int main(){
  char a[10];
  int i,k=0;
  scanf("%s", &a);
  for(i=0;i<strlen(a);i++){
    if(a[i]=='+')
      k++;
    else
      k--;
  }
  printf("%d",k);
  return 0;
}
//  [c]
#include<stdio.h>
int main(){
  char s[5];
  int i,j=0;
  scanf("%s",s);
  for(i=0;i<4;i++)j+=s[i]=='+'?1:-1;
  printf("%d",j);
}
//  [c]
#include<stdio.h>
int main(){
  int k=0;
  char c[4];
  scanf("%s",c);
  for(int i=0;i<4;i++){
    if(c[i]=='+') k++;
    else k--;
  }
  printf("%d\n",k);
}
//  [javascript]
var toInt = x=>parseInt(x,10);
var toIntArr = arr=>arr.map(x=>toInt(x));
function min(){var rest = arguments,val=rest[0];for(var i=1;i<rest.length;i++)if(rest[i]<val)val = rest[i];return val}
function max(){var rest = arguments,val=rest[0];for(var i=1;i<rest.length;i++)if(rest[i]>val)val = rest[i];return val}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

function Main(input){
	var ans = 0;
	for(var i = 0; i < 4; i++) ans += input[i]==='+'? 1: -1;

	console.log(ans);
}
//  [javascript]
'use strict'

function Main(input) {
  const list = input.split('');
  let answer = 0;

  for(let i=0; i<4; i++) {
    if(list[i] === '+') {
      answer++;
    } else {
      answer--;
    }
  }

  console.log(answer);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(input){

input=input.split("");

answer = 0;

for (i = 0; i < 4; i++) {
    if (input[i] == "+") {
        answer = answer + 1;
    }
    if (input[i] == "-") {
        answer = answer - 1;
    }
}

console.log(answer);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

func main() {
  var l string
  fmt.Scan(&l)

  s := 0

  for _, c := range l {
    if c=='+' {
      s += 1
    } else if c=='-' {
      s -= 1
    }
  }


  fmt.Println(s)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scan(&s)

	ans := 0
	for _, v := range s {
		if v == '+' {
			ans++
		} else if v == '-' {
			ans--
		}
	}
	fmt.Println(ans)
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - Eating Symbols Easy
	var S string
	fmt.Scanf("%s", &S)

	var answer int
	for i := 0; i < len(S); i++ {
		if S[i] == '+' {
			answer++
		} else {
			answer--
		}
	}
	fmt.Println(answer)
}
//  [ruby]
s=gets.chomp.split("")
p s.count(?+)-s.count(?-)
//  [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

S = gets.chomp

ans= 0
S.split('').each do |char|
  ans += char == '+' ? 1 : -1
end

puts ans
//  [ruby]
S = gets.chomp.split('')
ans = 0
S.each do |s|
  case s
  when '+' then ans+=1
  when '-' then ans-=1
  end
end
puts ans
//  [rust]
#[allow(unused_imports)] use proconio::{input, marker::{Bytes, Chars, Usize1, Isize1}};
#[allow(unused_imports)] use std::cmp::{min, max};
#[allow(unused_imports)] use superslice::Ext as _;

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

	let mut ans = 0isize;
	for i in 0..4 {
		if cs[i] == '+' {
			ans += 1;
		}
		else {
			ans -= 1;
		}
	}

	println!("{}", ans);
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {s: String};

    let mut count = 0;
    for si in s.chars() {
        if si == '+' {
            count += 1;
        } else {
            count -= 1;
        }
    }

    println!("{}", count)
}
//  [rust]
use proconio::{fastout, input};

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;

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

    let ans: isize = s
        .chars()
        .map(|c| match c {
            '+' => 1,
            '-' => -1,
            _ => 0,
        })
        .sum();
    println!("{}", ans);
}
//  [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 (S.match(/\+/g) || []).length - (S.match(/\-/g) || []).length;
};

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

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const s = input[0];

let result = 0;
for(const c of s) {
  switch(c) {
    case "+":
      result++;
      break;
    case "-":
      result--;
      break;
    default:
  }
}

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

const s = stdin.split('\n')[0].split('')

let res = 0
s.forEach(e => {
  if (e === '+') {
    res++
  } else {
    res--
  }
})

console.log(res)
//  [python]
N, A, B = map(int, input().split())
if N * A < B:
    print(N * A)
else:
    print(B)
//  [python]
n, a, b = map(int, input().split())

if n * a < b:
    print(n*a)
else:
    print(b)
//  [python]
n,a,b = map(int,input().split())
print(min(a*n, b))
//  [python]
n,a,b = map(int, raw_input().split())
print min(n*a, b)
//  [python]
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,A,B = inputIL()

print(min(N*A,B))
//  [python]
import sys
import math
from fractions import gcd
# import queue
# from collections import Counter
# from itertools import accumulate
# from functools import reduce

def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

big_prime = 1000000007

"""
# 標準入力取得
## 文字列
 =  sys.stdin.readline().rstrip()
 =  list(sys.stdin.readline().rstrip())

## 数値
 =  int(sys.stdin.readline())
 =  map(int, sys.stdin.readline().split())
 =  list(map(int, sys.stdin.readline().split()))
 =  [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""


N, A, B =  map(int, sys.stdin.readline().split())
print(min(N * A, B))
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main
{
	public static void main( String[] args ) throws IOException
	{
		Reader.init(System.in);
		int n = Reader.nextInt();
		int a = Reader.nextInt();
		int b = Reader.nextInt();
		int at = n*a;
		if ( at < b )
		{
			System.out.println(at);
		}
		else
		{
			System.out.println(b);
		}
	}
}

/** Class for buffered reading int and double values */
class Reader 
{
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) 
    {
        reader = new BufferedReader(new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) 
        {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
	
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
    
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		String input = br.readLine();
		String[] tmpArray = input.split(" ");
		int n = Integer.parseInt(tmpArray[0]);
		int a = Integer.parseInt(tmpArray[1]);
		int b = Integer.parseInt(tmpArray[2]);
		
		System.out.println(Math.min(n*a, b));
	}

}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
	public static void main(String[] args) throws IOException {
		try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
			int[] array = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
			int n = array[0];
			int a = array[1];
			int b = array[2];

			System.out.println(Math.min(n*a, b));
		}
	}
}
//  [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 a = sc.nextInt();
		int b = sc.nextInt();
		System.out.println(Math.min(n*a, b));
	}
}
//  [cpp]
#include <stdio.h>
#include <algorithm>

int main()
{
  int N, A, B;
  scanf("%d %d %d", &N, &A, &B);
  printf("%d\n", std::min(N*A, B));
  return 0;
}
//  [cpp]
#include<stdio.h>
int main()
{
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	if(a*b<=c)
	printf("%d\n",a*b);
	else
	printf("%d\n",c);
	
	return 0;
}
//  [cpp]
#include <stdio.h>

int main()
{
    int n,a,b;
    scanf("%d %d %d",&n, &a,&b);
    int x=n*a;
    int y=b;
    printf("%d\n", (x>y)?y:x);
    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

#define fastio 			ios::sync_with_stdio(0);	cin.tie(0); cout.tie(0);  cout<<fixed;  cout<<setprecision(12);
#define randomINT 		mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define	newl 			cout<<"\n"
#define DISP(as)		for(auto it : as) cout<<it<<" ";newl;
#define all(x)         	(x).begin(),(x).end()
#define mset(x,val)    	memset(x,val,sizeof(x))
#define newl           	cout<<"\n"
#define pb             	push_back
#define mp             	make_pair
#define f 				first
#define s 				second
#define dline          cerr<<"///REACHED///\n";
#define deb1(x)        cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y)      cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z)    cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';

typedef long long 				ll;
typedef long double 			ld;
typedef vector<ll> 				vll;
typedef pair<ll , ll> 			pll;
typedef pair<ld, ld> 			pld;
typedef unordered_map<ll, ll> 	um;
typedef vector<pll> 			vpll;

const ll 	MAX5 	= 	1e+5 + 7;
const ll 	MAX7 	= 	1e+7 + 7;
const ll 	MAXN 	= 	MAX7;
const ll   	INF   	=  	0x7f7f7f7f7f7f7f7f;
const int  	INFi 	=  	0x7f7f7f7f;
const ll 	MOD		=  	1e+9 + 7;

vll adj[MAXN]; ll visit[MAXN] = {};
int dx8[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};

// <------------- Declare Variables Here ------------> //

ll T = 1;
ll n, x, y, r, p;
string s, t;
// <------------- Implement Functions Here ----------> //



// <------------- Start of main() -------------------> //

void MAIN() {
	ll a,b;
	cin>>n>>a>>b;
	cout<<min(n*a,b);
}

int main() {
	fastio; randomINT;
	//cin>>t;
	while (T--) {
		MAIN();
	}
	return 0;
}
//  [cpp]
#include<stdio.h>
int main()
{
	int n,a,b;
	scanf("%d %d %d",&n,&a,&b);
	if(a*n>=b)
	printf("%d\n",b);
	if(a*n<b)
	printf("%d\n",a*n);
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for (int i=0;i<(n);i++)
//#define int long long  
int main(){
	int N,A,B;
	cin >> N >>A >> B;
	cout << min(A*N,B) << endl;
	
	return 0;
}
//  [c]
#include <stdio.h>

int main (void)
{
  int n, a, b;

  scanf("%d %d %d", &n, &a, &b);
  printf("%d", (n * a < b)? n * a: b);

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

int main(void)
{
	int n, a, b;
	int p1;
	
	scanf("%d %d %d", &n ,&a, &b);
	
	p1 = n * a;
	
	if(p1 > b){
		printf("%d\n", b);
	}else{
		printf("%d\n", p1);
	}
	
	return 0;
}
//  [c]
#include <stdio.h>
int main(void){
  int N,A,B;
  scanf("%d %d %d",&N,&A,&B);
  int S;
  S=N*A;
  if(S>B){
    printf("%d\n",B);
  }
  else{
    printf("%d\n",S);
  }
  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 n, a, b;
    int ans;
    
    scanf("%d%d%d", &n, &a, &b);
    
    ans=fmin(n*a, b);
    
    printf("%d", ans);
    
    return 0;
}
//  [c]
#include <stdio.h>
 
int main (void) {
  int a , b, n;
  scanf("%d %d %d",&n, &a, &b);
  if(a*n>b){
    printf("%d\n",b);
  }else {
    printf("%d\n",a*n);
  } 
  return 0;
}
//  [javascript]
function main(input) {
  var list = input[0].split(" ").map(v=>v-0);
  console.log(Math.min(list[0]*list[1], list[2]));
    
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim().split("\n"))
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ");
if(input[0]*input[1]<=input[2]){
  console.log(input[0]*input[1])
}else{
  console.log(input[2])
}
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

const main = input => {
	const args = input.split('\n').map(arg => arg.split(' '))
	const n = parseInt(args[0][0], 10)
	const a = parseInt(args[0][1], 10)
	const b = parseInt(args[0][2], 10)
	console.log(Math.min(a * n, b))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var g_input = '';
process.stdin.on('data', function(chunk) {
    g_input += chunk;
});

process.stdin.on('end', function() {
    Main(g_input.split(/\r?\n/));
});

function Main(input) {

    var params = input[0].split(' ');
    var n = parseInt(params[0], 10);
    var a = parseInt(params[1], 10);
    var b = parseInt(params[2], 10);

    if (a * n < b) {
        console.log(a * n);
    }
    else {
        console.log(b);
    }

    return 0;
}
//  [javascript]
    // inputに入力データ全体が入る
    function Main(input) {
    	// 1行目がinput[0], 2行目がinput[1], …に入る
    	input = input.split("\n");
      tmp = input[0].split(" ");
      
    	//文字列から10進数に変換するときはparseIntを使います
    	var N = parseInt(tmp[0], 10);
    	var A = parseInt(tmp[1], 10);
    	var B = parseInt(tmp[2], 10);

      var CalcA = A * N;

      if( CalcA <= B){
      	console.log('%d',CalcA);
      }else{
        console.log('%d',B);
      }

    	//出力
    	//console.log('%d %s',a+b+c,s);
    }

    Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) { // input="2312 312 312"
    tmp = input.split(" "); // [ "2312","312" ,"312"  ]
    //文字列から10進数に変換するときはparseIntを使います
    var A = parseInt(tmp[1]); // tmp[0] == "2312" parseInt(..) == 2312
    var B = parseInt(tmp[2]);
    var N = parseInt(tmp[0]);
    var NA = 0;
    NA = N * A;
    if (NA <= B) {
        console.log(NA)
    } else if (NA >= B) {
        console.log(B)
    };
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
)

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

	if n*a < b {
		fmt.Println(n * a)
	} else {
		fmt.Println(b)
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var n, a, b, na int
	fmt.Scanf("%d %d %d", &n, &a, &b)

	na = n * a

	if na <= b {
		fmt.Println(na)
	} else {
		fmt.Println(b)
	}
}
//  [go]
package main

import "fmt"

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

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

	fmt.Println(min(a*n, b))
}
//  [go]
package main

import (
	"fmt"
)

func main() {
  var N, A, B int 
  fmt.Scanf("%d %d %d", &N, &A, &B)
  
  ans := A * N
  if ans > B {
    ans = B
  }

  fmt.Printf("%d\n", ans)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func stringSliceScanner(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scanner()
	}
	return a
}
func intSliceScanner(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = intScanner()
	}
	return a
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n, a, b := intScanner(), intScanner(), intScanner()
	fmt.Println(smaller(n*a, b))
}
//  [ruby]
n, a, b = gets.chomp.split(" ").map(&:to_i)
puts [n*a, b].min
//  [ruby]
N, A, B = gets.chomp.split(" ").map(&:to_i)

puts N*A < B ? N*A : B
//  [ruby]
n,a,b=gets.split.map(&:to_i);p [n*a,b].min
//  [ruby]
a,b,c=gets.split.map(&:to_i)
p [a*b,c].min
//  [ruby]
n, a, b = gets().chomp.split("\s").map{|x| x.to_i}

puts n * a > b ? b : n * a
//  [ruby]
N,A,B=gets.split.map(&:to_i)
puts [N*A,B].min
//  [rust]
use std::io;
use std::cmp::min;

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

fn main() {
	let v:Vec<i32> = procon_read();
	let n = v[0];
	let a = v[1];
	let b = v[2];
	println!("{}", min(a*n, b));
}
//  [rust]

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

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


fn main() {
    let n: usize = read();
    let a: usize = read();
    let b: usize = read();
    if n * a < b {
        println!("{}", n * a);
    } else {
        println!("{}", b);
    }
}
//  [rust]
macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
            get!($t)
        ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
            get!($($t),*)
        ).collect::<Vec<_>>()
    };
}

use std::cmp;

fn main() {
    let (n, a, b) = get!(i32, i32, i32);
    println!("{}", cmp::min(a * n, b));
}
//  [rust]
#![allow(unused_imports)]
// use itertools::Itertools;
use proconio::{input, marker::*};

fn main() {
    input! {
        n: usize,
        a: usize,
        b: usize
    };
    println!("{}", std::cmp::min(n * a, b));
}
//  [rust]
use text_io::*;
use std::collections::HashMap;
use std::process::exit;

fn main() {
    let t:usize = read!();
    let a:usize = read!();
    let b:usize = read!();
    if t*a<b {
        println!("{}",t*a);
    }
    else {
        println!("{}",b);
    }
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(min(i[0]*i[1],i[2]))
//  [swift]
import Glibc
extension String: CollectionType {}

var nab = readLine()!.split(" ").map { Int($0)! }
print(nab[0]*nab[1]>nab[2] ? nab[2] : nab[0]*nab[1])
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const N = parseInt(input[0], 10);
  const A = parseInt(input[1], 10);
  const B = parseInt(input[2], 10);
  
  if (N*A>B) {
    console.log(B);
  }else if(N*A==B){
    console.log(B);
  }else{
    console.log(N*A);
  }
  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

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

console.log(Math.min(n*a, b))
//  [typescript]
import * as fs from "fs";

let input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const [n, a, b] = input[0].split(" ").map((x: string): number => +x);

console.log(Math.min(n*a,b));
//  [typescript]
import { readFileSync } from "fs";

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

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

  return Math.min(A * N, B);
};

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

namespace AtCoder {
    export interface Paramable {
        readonly args: string[][];
    }

    export interface Task {
        main(this: Task): void;
    }
}

namespace AtCoder.abc001 {
    export class TaskA implements AtCoder.Task, AtCoder.Paramable {
        public constructor(public readonly args: string[][]) {
        }

        public main(this: TaskA): void {
            const [n, a, b]: number[] = this.args[0].map(Number);
            console.log(Math.min(n * a, b));
        }
    }

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

const main = ()=>{
  let [a,b,c]=nrin(3)
  out(min(a*b,c))
}
main()
//  [python]
N,M=list(map(int,input().split()))
print(["No","Yes"][N==M])
//  [python]
N, M = map(int, input().split())


if N == M:
    print("Yes")
else:
    print("No")
//  [python]
N, M = map(int, input().split())
if N == M:
  print('Yes')
else:
  print('No')
//  [python]
import math
import numpy as np
from fractions import gcd
import fractions
import statistics
import collections
from functools import reduce
import itertools
from collections import defaultdict
import bisect
from fractions import Fraction
 
N,M=map(int, input().split())

if (N == M):
    print('Yes')
else:
    print('No')
//  [python]
import sys
from collections import defaultdict
from collections import deque
import numpy as np
import heapq
from heapq import heappush, heappop


#read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

N, M = map(int, input().split())
a = N - M
if N - M > 0:
    ans = 'No'
else:
    ans = 'Yes'

print(ans)
//  [python]
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353


N, M = list(map(int, sys.stdin.buffer.readline().split()))
ok = N == M
if ok:
    print('Yes')
else:
    print('No')
//  [java]

import java.io.*;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;

public class Main
{
	public static void main(String []args)throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String []s=br.readLine().split(" ");
		int n = Integer.parseInt(s[0]);
		int m = Integer.parseInt(s[1]);
		
		if(n==m)
			out.println("Yes");
		else
			out.println("No");
	}
}
//  [cpp]
#include <stdio.h>
int main()
{
    int b,c, a;
    scanf("%d%d",&a,&b);
    if(a==b)
        printf("Yes\n");
    else
        printf("No\n");




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


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

	if(n==m)
		printf("Yes\n");
	else 
		printf("No\n");

	return 0;
	
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0;i<(n);i++)
typedef long long ll;
using namespace std;

int main() {
  int n, m;
  cin >> n >> m;
  if (n == m) {
 	cout << "Yes" << endl;
  } else {
 	cout << "No" << endl;
  }
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#include <unistd.h>
using namespace std;

int main()
{
 	usleep(1999000);
  	int a,b;
  	cin>>a>>b;
 	cout<<((a==b)?"Yes":"No")<<"\n";
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int i,j;
    scanf("%d%d",&i,&j);
    if(i==j) printf("Yes\n");
    else printf("No\n");
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(void){
  int n, m;
  scanf("%d %d", &n, &m);
  if(n == m)
    printf("Yes\n");
  else
    printf("No\n");
  
  return 0;
}
//  [c]

#include<stdio.h>
int main()
{
    int A,B;


  scanf("%d %d",&A,&B);
    if(A!=B)
    {
        printf("No");
    }
    else
        printf("Yes");
        return 0;
}
//  [c]
#include <stdio.h>

int main (){
	int a, b;
	scanf("%d %d", &a, &b);
	if (a == b ){
		printf("Yes");
	}
	else {
		printf("No");
	}
	return 0;
}
//  [c]
#include<stdio.h>
main()
{
    int k,n,m;
    scanf("%d %d",&n,&m);
    k= (n==m)? printf("Yes"):printf("No");
}
//  [c]
#include <stdio.h>
int main(){
	int M,N;
	scanf ("%d%d",&N,&M);
	if (M==N){
		printf("Yes\n");
	}
	else {
		printf("No\n");
	}
	return 0;
}
//  [javascript]
function main(arg) {
	arg = arg.trim().split(' ');
	if(arg[0] === arg[1]){
    	console.log('Yes');
    } else {
    	console.log('No');
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
    input = input.split(' ');
    inputA = parseInt(input[0]);
    inputB = parseInt(input[1]);
    out = 'No';
    
    if(inputA==inputB){
        out = 'Yes';
    }

    console.log(out);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const inputArr = input.split(" ");
  const N = Number(inputArr[0]);
  const M = Number(inputArr[1]);
  if (N === M) {
    console.log('Yes')
  }
  else {
    console.log('No')
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
var output;
var input = require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n");
var obj = {
  "list" : input,
  "index" : 0,
  "max" : input.length,
  "next" : function(){
    if(!this.hasNext()){return null;}
    var returnObj = this.list[this.index];
    this.index++;
    return returnObj;
  },
  "hasNext" : function(){return (this.index < this.max);}
}
Main();
function next(){return obj.next();}
function hasNext(){return obj.hasNext();}
function myout(t){console.log(t);}//standard output
function myerr(t){console.error(t);}//standard error
//[no]param
//不明値:何もしない 異常時:文字列「error」を返す（できる？）
//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 "error";}}
function Main() {
  var tmp = myconv(next(),4);
  if(tmp[0] == tmp[1]){
     myout("Yes");
     }else{
     myout("No");
     }
}
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
	console.log(a[0] == a[1] ? "Yes" : "No");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

	n := nextInt()
	m := nextInt()
	if n == m {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}

}

// ---- readfunc
func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}
//  [go]
// +build ignore
package main

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

func solve(sc *scanner, wr *bufio.Writer) int {
	N := sc.i()
	M := sc.i()
	if N == M {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
	return 0
}

func main() {
	sc := newScanner(os.Stdin)
	wr := bufio.NewWriter(os.Stdout)
	ret := solve(sc, wr)
	wr.Flush()
	os.Exit(ret)
}

// I/O
type scanner struct {
	sc *bufio.Scanner
}

func newScanner(input io.Reader) *scanner {
	sc := bufio.NewScanner(input)
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 1024), int(1e+9))
	return &scanner{sc}
}

func (s *scanner) s() string {
	s.sc.Scan()
	return s.sc.Text()
}

func (s *scanner) i() int {
	i, e := strconv.Atoi(s.s())
	if e != nil {
		panic(e)
	}
	return i
}

func (s *scanner) f() float64 {
	f, e := strconv.ParseFloat(s.s(), 64)
	if e != nil {
		panic(e)
	}
	return f
}

func (s *scanner) bs() []byte {
	return []byte(s.s())
}

func (s *scanner) is(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = s.i()
	}
	return res
}

func (s *scanner) fs(n int) []float64 {
	res := make([]float64, n)
	for i := 0; i < n; i++ {
		res[i] = s.f()
	}
	return res
}
//  [go]
package main

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

//Util
func nextStr() string {
	sc.Scan()
	return sc.Text()
}

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

func maxInt(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func minInt(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

func absInt(a int) int {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func absFloat64(a float64) float64 {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func minFloat64(a, b float64) float64 {
	if a > b {
		return b
	} else {
		return a
	}
}

func str2Int(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

//Main
var sc = bufio.NewScanner(os.Stdin)

var N, M int

func main() {
	sc.Split(bufio.ScanWords)
	N, M = nextInt(), nextInt()

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

import (
	"fmt"
)

func main() {

	var N, M int
	fmt.Scanf("%d %d", &N, &M)

	if N == M {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}

}
//  [ruby]
puts (if gets.split.uniq.length==1 then "Yes" else "No" end)
//  [ruby]
n,m = gets.split.map(&:to_i)
puts n == m ? "Yes" : "No"
//  [ruby]
n, m = gets.chomp.split.map(&:to_i)
if n == m
  puts "Yes"
else
  puts "No"
end
//  [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

puts N == M ? 'Yes' : 'No'
//  [ruby]
a,b=gets.split.map &:to_i
puts a==b ? :Yes : :No
//  [ruby]
puts gets.chomp.split.uniq.size == 1 ? 'Yes' : 'No'
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.split_whitespace();
	let n:i32 = match iter.next().unwrap().parse() {
		Ok(n) => n,
		Err(_) => panic!(""),
	};
	let m:i32 = match iter.next().unwrap().parse() {
		Ok(n) => n,
		Err(_) => panic!(""),
	};
	if n == m {
		println!("Yes");
	}else{
		println!("No");
	}
}
//  [rust]
/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

fn main() {
    input! {
        n: u32,
        m: u32,
    }
    println!("{}", if n == m {"Yes"} else {"No"});
}
/* vim:set foldmethod=marker: */
//  [rust]
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> Option<T> {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok()
}

fn main() {
    let n: usize = read().unwrap();
    let m: usize = read().unwrap();
    if n == m {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [swift]
let arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

let n = arr[0]
let m = arr[1]

if( n == m ) {
    print("Yes")
} else {
    print("No")
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func main() {
    let nm = readInts()
    
    if nm[0] == nm[1] {
        print("Yes")
    } else {
        print("No")
    }
}

main()
//  [typescript]
function Main(input) {
    lines = input.split("\n");
    const [n, m] = lines.shift().split(' ');
    
    console.log(n == m ? 'Yes' : 'No');
}

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

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

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

const [n, m] = input[0].split(' ').map((x: string): number => +x);

if (n===m){
	console.log('Yes');
}else{
	console.log('No');
}
//  [typescript]
'use strict'
const main = (input: string) => {
    const std: string[] = input.split(' ')
    const n = ~~std.shift()
    const m = ~~std.shift()
    console.log(n-m === 0 ? 'Yes' : 'No')
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim())
//  [typescript]
"use strict";

function compareFunc(a, b) {
  return a - b;
}
const main = arg => {
  const input = arg.trim().split("\n");
  const N = parseInt(input[0].split(" ")[0]);
  const M = parseInt(input[0].split(" ")[1]);
  if (N == M) {
    console.log("Yes");
  } else {
    console.log("No");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
class AtCoder {
  // 入力系
  input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);
  input_i=-1;
  n(){
    this.input_i++;
    return Number(this.input[this.input_i]);
  }
  nn(n){
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.n());
    }
    return a;
  }
  s(){
    this.input_i++;
    return String(this.input[this.input_i]);
  }
  ss(n){
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.s());
    }
    return a;
  }

  // コンソール
  o(...a:any){
    console.log(...a);
  }

  // Math
  abs(a:number){
    return Math.abs(a);
  }
  min(...a:number[]){
    return Math.min(...a);
  }
  max(...a:number[]){
    return Math.max(...a);
  }
  floor(a:number){
    return Math.floor(a);
  }
  ceil(a:number){
    return Math.ceil(a);
  }
  round(a:number){
    return Math.round(a);
  }

  // ソート
  asc(ar:number[]){
    const t=[...ar];
    ar.sort((a,b)=>{return a-b});
  }
  desc(ar:number[]){
    const t=[...ar];
    ar.sort((a,b)=>{return b-a});
  }

  // 自作
  gcd(...arr):number{
    for(let i=0;i<arr.length-1;i++){
      let [x,y]=[arr[i],arr[i+1]];
      while(y){
        [x,y]=[y,x%y];
      }
      arr[i+1]=x;
    }
    return arr[arr.length-1];
  };
  lcm(...arr):number{
    for(let i=0;i<arr.length-1;i++){
      let [x,y]=[arr[i],arr[i+1]];
      while(y){
        [x,y]=[y,x%y];
      }
      arr[i+1]=arr[i]*arr[i+1]/x;
    }
    return arr[arr.length-1];
  };
  isPrime(n:number):boolean{
    if(n < 2) return false;
    const suq=Math.sqrt(n);
    for(let i=2;i<=suq;i++){
      if(n%i==0){
        return false;
      }
    }return true;
  };
  deduplicate(a:any[]):any[]{
    return Array.from(new Set(a));
  };
}

/* [入力]
  const [H,W]=o.nn(2)
  const [N,M]=o.nn(2)
  const N=o.n()
  const S=o.s()
  const arr1=[]
  for(let i=0;i<N;i++)arr1.push(o.n())
 */

/* [BFS,DFS]
  const [H,W]=o.nn(2),map=new Array(H),save=new Array(H)
  const DH=[0,0,-1,1]
  const DW=[1,-1,0,0]
  for(let i=0;i<H;i++){
    map[i]=o.s().split('')
    save[i]=new Array(W)
    save[i].fill(-1)
  }
  // let queue=[[?,?,1]]
  // save[?][?]=0
  while(queue.length>0){
    let [h,w,c]=queue.shift()
    for(let i=0;i<4;i++){
      if(h+DH[i]<0 || h+DH[i]>=H || w+DW[i]<0 || w+DW[i]>=W){
        continue
      }
      if(map[h+DH[i]][w+DW[i]]==?){
        continue
      }
      if(save[h+DH[i]][w+DW[i]]==-1){
        queue.push([h+DH[i], w+DW[i], c+1])
        save[h+DH[i]][w+DW[i]]=c
      }
    }
  }
*/
const o = new AtCoder()

o.o(o.n()==o.n()?'Yes':'No')
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync('/dev/stdin', 'utf8').split(/[ \n]/);
const n = +input[0];
const m = +input[1];

if (n === m) {
  console.log('Yes');
} else {
  console.log('No');
}
//  [python]
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
from statistics import mean,median,mode

INF = float("inf")

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    # lsはソート済みであること
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

def I():
    return int(input())

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

def RI():
    return list(map(int,input().split()))

def CI(n):
    return [ int(input()) for _ in range(n) ]

def LI(n):
    return [ list(map(int,input().split())) for _ in range(n) ]

def S():
    return input()

def MS():
    return input().split()

def RS():
    return list(input())

def CS(n):
    return [ input() for _ in range(n) ]

def LS(n):
    return [ list(input()) for _ in range(n) ]

# ddict = defaultdict(lambda: 0)
# ddict = defaultdict(lambda: 1)
# ddict = defaultdict(lambda: int())
# ddict = defaultdict(lambda: list())
# ddict = defaultdict(lambda: float())

s = S()
t = S()

s = list(s)
s.sort()
t = list(t)
t.sort(reverse=True)

if s<t:
    print('Yes')
else:
    print('No')
//  [python]
s = ''.join(sorted(list(input())))
t = ''.join(sorted(list(input()), reverse=True))
print('Yes' if s < t else 'No')
//  [python]
a = sorted(raw_input())
b = sorted(raw_input())[::-1]
print 'Yes' if a < b else 'No'
//  [java]
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    static Scanner scanner = new Scanner(System.in);

    public static void main(String[]$) {
        String s = scanner.next().chars().mapToObj(ch -> String.valueOf((char)ch)).sorted().collect(Collectors.joining());
        String t = scanner.next().chars().mapToObj(ch -> String.valueOf((char)ch)).sorted(Comparator.reverseOrder()).collect(Collectors.joining());
        System.out.println(s.compareTo(t) < 0 ? "Yes" : "No");
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Collectors;

public class Main {

	public static void main(String[] args) throws IOException{
		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		String word1 = stdin.readLine();
		String word2 = stdin.readLine();
		String sorted1 = Arrays.stream(word1.split("")).sorted().collect(Collectors.joining());
		String sorted2 = Arrays.stream(word2.split("")).sorted(Comparator.reverseOrder()).collect(Collectors.joining());
		String answer = sorted2.compareTo(sorted1) > 0 ? "Yes" : "No" ;
		System.out.println(answer);
	}

}
//  [java]
import java.util.Collections;
import java.util.Scanner;
import java.util.stream.Collectors;

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

        String s = sc.next();
        String t = sc.next();

        System.out.println(solve(s, t) ? "Yes" : "No");

        sc.close();
    }

    static boolean solve(String s, String t) {
        return s.chars().sorted().mapToObj(ch -> String.valueOf((char) ch)).collect(Collectors.joining())
                .compareTo(t.chars().boxed().sorted(Collections.reverseOrder())
                        .map(x -> String.valueOf((char) x.intValue())).collect(Collectors.joining())) < 0;
    }
}