jiahuimbzuai/CoQuIR huggingface dataset:
//  [python]
A,B = map(int,input().split())

print(max(A+B,A-B,A*B))
//  [python]
a,b=map(int,input().split())
print(max(a+b,a-b,a*b))
//  [python]
N = int(input())
A = list(map(int, input().split()))
A2 = []
Z = []
ans = 0
zerocnt = 0
for ai in A:
    if ai == 0:
        zerocnt += 1
    elif zerocnt >= 1:
        A2 += [0]
        Z += [zerocnt]
        ans += (zerocnt * (zerocnt+1)) // 2
        zerocnt = 0
    if ai != 0:
        A2 += [ai]
        Z += [1]
        ans += 1

if zerocnt >= 1:
    A2 += [0]
    Z += [zerocnt]
    ans += (zerocnt * (zerocnt+1)) // 2
    zerocnt = 0

for i, ai in enumerate(A2):
    aixor = ai
    sumA = ai
    for j in range(i+1, min(i+41, len(A2))):
        aj = A2[j]
        aixor = aixor ^ aj
        sumA += aj
        if aixor != sumA:
            break
        else:
            ans += (Z[i] * Z[j])
        
print(ans)
//  [python]
N = int(input())
S = input()

max_count = 0
for i in range(0, N-1):
  X = S[0:i+1]
  Y = S[i+1:]

  X_set = set(X)
  Y_set = set(Y)

  count = len(X_set & Y_set)
  if max_count < count:
    max_count = count

print(max_count)
//  [python]
a,b=map(int,input().split())
print(max(a+b,a=b,a*b))
//  [cpp]
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    int major;

    major = a+b;
    major = max(major, a-b);
    major = max(major, a*b);
    printf("%d\n", major);
}
//  [cpp]
#include <stdio.h>

int main()
{
  int A, B;
  scanf("%d %d", &A, &B);
  
  if(A+B <= A-B)
  {
    if(A-B > A*B)
    {
      printf("%d\n", A-B);
    }
  }
  else
  {
    if(A*B <= A+B)
    {
      printf("%d\n", A+B);
    }
  }

  if(A-B <= A*B)
  {
    if(A*B > A+B)
    {
      printf("%d\n", A*B);
    }
  }
  
  if( (A+B == A-B) && (A-B == A*B))
    printf("%d\n", A+B);
  
  return 0;
}
//  [cpp]
#include <stdio.h>
int main()
{
   int a,b,c[4],i,temp=0;
   scanf("%d %d",&a,&b);
   c[0]=a+b;
   c[1]=a-b;
   c[2]=a*b;
   if(c[0]>c[1]&&c[0]>c[2]){
     printf("%d\n",c[0]);
   }
   else if(c[2]>c[0]&&c[2]>c[1]){
    printf("%d\n",c[2]);
   }
   else{
    printf("%d\n",c[1]);
   }
   return 0;
   }
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){
  int N;
  string str;
  cin>>N>>str;
  vector<int> dataW(N);
  vector<int> dataE(N);
  if(str.at(0)=='W'){dataW.at(0)=1;}else{dataW.at(0)=0;}
  if(str.at(N-1)=='E'){dataE.at(0)=1;}else{dataE.at(0)=0;}
  for(int i=1;i<N;i++){
    if(dataW.at(i)=='W'){
      dataW.at(i)=dataW.at(i-1)+1;
    }else{
      dataW.at(i)=dataW.at(i-1);
    }
    if(dataE.at(N-1-i)=='E'){
      dataE.at(i)=dataE.at(i-1)+1;
    }else{
      dataE.at(i)=dataE.at(i-1);
    }
  }
  
  int cnt=dataE.at(N-2);
  for(int i=1;i<N-1;i++){
    int tmp=dataW.at(i-1)+dataE.at(N-2-i);
    cnt=min(cnt,tmp);
  }
  cnt=min(cnt,dataW.at(N-2));
  cout<<cnt<<endl;
}
//  [cpp]
#include <bits/stdc++.h>
#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
using namespace std;
 
int main() {
    //input
    int n;cin >> n;
    string str; cin >> str;
    vector<char> alp{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
    vector<int> f(25,0);
    vector<int> l(25,0);
    vector<int> count(25,0);
 
    //compute
    int ans;
    ans = 0;
 
    for(int j = 0; j < 25; j++){
        for(int i = 0; i < n; i++){
            if(str.at(i) == alp[j]){
                f[j] = i;
                break;
            }
        }
        for(int i = 0; i < n - 1;i++){
            if(str.at(n - 1 - i) == alp[j]){
                l[j] = n - 1 - i;
                break;
            }
                
    }
    }
 
    for(int i = 0; i < 25; i++) {
        for(int j = 0; j < l[i] - f[i] ;j++){
            count[f[i] + j] += 1;
        }
    }
 
    sort(count.rbegin(),count.rend());
 
    ans = count[0];
 
    //output
    cout << ans << endl;
 
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{
    int a,b,x,y,z;
    cin >> a >> b;
    if(a>=-1000 && b<=1000)
    {
        x=a+b;
        y=a-b;
        z=a*b;
        if(x>y && x>z) cout << x << endl;
        else if(y>x && y>z) cout << y << endl;
        else cout << z << endl;
    }
    return 0;
}
//  [c]
#include <stdio.h>

int main(void)
{
	int A,B;
	int s[4],temp;
	scanf("%d %d",&A,&B);
	s[0]=A+B;
	s[1]=A-B;
	s[2]=A*B;
	if(s[0]>s[1]){
		s[1]=s[0];
	}
	if(s[1]>s[2]){
		s[2]=s[1];
	}
	printf("%d\n",s[2]);
	return 0;
}
//  [c]
#include<stdio.h>
int max3(int x,int y,int z){
  int max=0;
  if(x>y){
    max=x;
  }else{
    max=y;
  }
  if(max<z){
    max=z;
  }
  return max;
}
int main(void){
  int a,b;
  scanf("%d %d",&a,&b);
  int add=a+b;
  int sub=a-b;
  int mul=a*b;
  int ans=max3(add,sub,mul);
  printf("%d\n",ans);
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
void input_int(int*);
void output_int(int);

int main(int argc, const char * argv[]) {
    int a,b;
    input_int(&a);
    input_int(&b);
    int x=a+b,y=a-b,z=a*b;
    int mx=x;
    if (mx<y) {
        mx=y;
    }
    if (mx<z) {
        mx=z;
    }
    output_int(mx);
    return 0;
}

void input_int(int *x){
    int k,negative=0;
    *x=0;
    while (1) {
        k = getchar_unlocked();
        if (k=='-'){
            negative=1;
            break;
        }
        if ('0'<=k && k<='9') {
            *x = k-'0';
            break;
        }
    }
    
    while (1) {
        k = getchar_unlocked();
        if (k<'0'||k>'9'){
            break;
        }
        *x=(*x)*10+k-'0';
    }
    if (negative){
        *x=-(*x);
    }
}

void output_int(int x){
    char k[10];
    int negative=0,k_index=0;
    if (x<0){
        negative=1;
        x=-x;
    }
    while (x) {
        k[k_index++]=x%10;
        x/=10;
    }
    if (k_index==0){
        k[k_index++]=0;
    }
    if (negative){
        putchar_unlocked('-');
    }
    while (k_index--) {
        putchar_unlocked(k[k_index]+'0');
    }
    putchar_unlocked('\n');
}
//  [c]
#include<stdio.h>
int main()
{
     int a,b,p,q,r;
     scanf("%d %d",&a,&b);
     p=a+b;
     q=a-b;
     r=a*b;
     if(p>q&&p>r)
     printf("%d\n",p);
     else if(q>p&&q>r)
         printf("%d\n",q);
     else
          printf("%d\n",r);
}
//  [c]
#include<stdio.h>
int main()
{
     int a,b,p,q,r,x;
     scanf("%d %d",&a,&b);
     p=a+b;
     q=a-b;
     r=a*b;
     if(p>q&&p>r)
     printf("%d\n",p);
     else if(q>p&&q>r)
         printf("%d\n",q);
     else
          printf("%d\n",r);
}
//  [c]
#include<stdio.h>
int main()
{
    int a,b,p,m,i;

    scanf("%d %d",&a,&b);

    p = a+b;
    m = a-b;
    i = a*b;

    if(p>m && p>i) printf("%d\n",p);

    else if(m>p && m>i) printf("%d\n",m);

    else if(i>m && i>p) printf("%d\n",i);

    else if(p==0 && m==0 && i==0) printf("%d\n",p);

    return 0;
}
//  [javascript]
// 2019/04/27
// AtCoder Beginner Contest 098 - A
// (stdin: type Ctrl + D after input)

"use strict";
 
function Main(in_input){
    // Modify Input
    var in_lines = in_input.split("\n");
    var in_line1 = in_lines[0].split(" ");
    var a = parseInt(in_line1[0], 10);
    var b = parseInt(in_line1[1], 10);

    // Calc Answer
    var c_max = Math.max(a+b, a-b, a*b) + 0;

    // Output
    console.log(c_max);
}
 
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
	input1 = input.split(' ');
    input2 = input1.map(input1=>parseInt(input1,10));
    a = input2[0] + input2[1];
    b = input2[0] - input2[1];
    c = input2[0] * input2[1];

    console.log(Math.max(a, b, c)+0);
}
 
Main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
// https://abc098.contest.atcoder.jp/tasks/abc098_a

function parse(input) {
  return input
    .trim()
    .split(" ")
    .map(number => parseInt(number, 10))
}

function f(a, b) {
  const wa = a + b
  const sa = a - b
  const seki = a * b

  var max = wa
  max = sa > max ? sa : max
  max = seki > max ? seki : max

  return max
}

module.exports = {
  parse,
  f,
}

function Main(input) {
  const arr = parse(input)
  const a = arr[0]
  const b = arr[1]

  console.log("%s", f(a, b))
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
const main = stdin => {
  const input = stdin.trim().split('\n')
  const [A, B] = input[0].split(' ').map(x => parseInt(x))
  console.log(Math.max(A + B, A - B, A * B))
}


// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
let [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(" ").map(Number);
console.log(Math.max(a + b, a - b, a * b));
//  [go]
package main

import (
	"fmt"
)

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

	add := a + b
	sub := a - b
	multiple := a * b

	ans := add
	if ans < sub {
		ans = sub
	}
	if ans < multiple {
		ans = multiple
	}
	fmt.Println(ans)
}
//  [go]
// きりみんちゃんの配信からきました
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	fmt.Println(max(a*b, max(a+b, a-b)))
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
//  [go]
package main

import (
	"fmt"
)

func max(n ...int) int {
	m := n[0]
	for _, v := range n[1:] {
		if v > m {
			m = v
		}
	}
	return m
}

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	fmt.Println(max(a, b))
}
//  [go]
package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b float64
	fmt.Println(math.Max(math.Max(a+b, a-b), a*b))
}
//  [go]
package main

import (
    . "fmt"
    "math"
)

func main() {
    var a, b float64
    Scanf("%f %f", &a, &b)

    max := math.Max(a + b, math.Max(a - b, a * b))
    Println(max)
}
//  [ruby]
a, b = gets.chomp.split(" ").map(&:to_i)
puts [a+b, a-b, a*b].max
//  [ruby]
a = gets.split(' ').map(&:to_i)
b = []
b[0] = a[0] + a[1]
b[1] = a[0] - a[1]
b[2] = a[0] * a[1]

p b.max
//  [ruby]
a,b = gets.split.map(&:to_i)
puts [a+b,a-b,a*b].max
//  [ruby]
a,b = gest.strip.split.map(&:to_i)
puts [a*b,a+b,a-b].max
//  [ruby]
a, b = gets.split.map &:to_i
p [a+b.a-b,a*b].max
//  [ruby]
a, b = gets.split.map :to_i
p [a+b.a-b,a*b].max
//  [rust]
#[macro_use]
pub mod basic_stdin {
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    use std::io::stdin;
    use std::io::Read;

    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed reading char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed parsing")
}

}

#[macro_export]
macro_rules! test_function {
    (func = $func:expr, $($input:expr => $output:expr),* $(,)*) => {
        $(
            assert_eq!($func(std::io::Cursor::new($input)) , $output);
        )*
    };
}

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

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

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

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

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

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

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

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

fn main() {
    let stdin = std::io::stdin();
    let ret = solve(stdin.lock());

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

fn solve<T: std::io::Read>(reader: T) -> i64 {
    input_macro! {
        reader = reader,
        a: i64,
        b: i64,
    }

    let x = a + b;
    let y = a - b;
    let z = a * b;

    let vec = vec![x, y, z];
    vec.into_iter().max().unwrap()
}

#[cfg(test)]
mod tests {

    #[test]
    fn test_solve_function() {
        atcorder::test_function! {
            func = super::solve,
            "3 1" => 4,
        }
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;
 
/* 
The read function reads a string according to each one. 
*/
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")
}

//main function
fn main() {
    let a:i64 = read();
    let b:i64 = read();
    let mut max:i64 = a+b;
    if max < a-b {
	max = a-b;
    }
    if max < a*b{
	max = a*b;
    }
    println!("{}",max);
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

use std::cmp::max;

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

    let c = a + b;
    let d = a - b;
    let e = a * b;

    println!("{}", max(c, max(d, e)));
}
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
use proconio::input;
use proconio::fastout;
use proconio::marker::{Chars};

#[fastout]
fn main() {
    input! {
        a:i32,b:i32,
    }
    let v=vec![a+b,a-b,a*b];
    let mx=v.into_iter().fold(i32::MIN,i32::max);
    println!("{}",mx);
}
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
use proconio::input;
use proconio::fastout;
use proconio::marker::{Chars};

#[fastout]
fn main() {
    input! {
        a:i32,b:i32,
    }
    let v=vec![a+b,a-b,a*b];
    let mx=v.into_iter().fold(0,i32::max);
    println!("{}",mx);
}
//  [rust]
macro_rules! input { (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut 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")
    };
}
use std::cmp::min;
fn main() {
    input! {
        n: usize,
        s: chars,
    }
    let mut cnt = 0;
    for i in 0..n {
        if s[i] == 'E' {
            cnt += 1;
        }
    }
    let mut ret = cnt;
    for i in 0..n - 1 {
        if s[i - 1] == 'W' {
            cnt += 1;
        }
        if s[i] == 'E' {
            cnt -= 1;
        }
        ret = min(ret, cnt);
    }
    println!("{}", ret);
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(max(i[0]+i[1],i[0]-i[1],i[0]*i[1]))
//  [swift]
import Foundation

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

var a = Int(split[0])!
//String -> Intの型変換はnilが返る可能性があるので、ラップされたOptional<Int>型が返るので強制アンラップ
var b = Int(split[1])!

var maxValue = a+b

if (maxValue < a-b){
    maxValue = a-b
}

if (maxValue < a*b){
    maxValue = a*b
}

print(maxValue)
//  [swift]
import Foundation

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

var A = Int(split[0])!
//String -> Intの型変換はnilが返る可能性があるので、ラップされたOptional<Int>型が返るので強制アンラップ
var B = Int(split[1])!

let value = max(A+B, A-B, A*B)
print(value)
//  [swift]
//
//  main.swift
//  AtCoder
//
//  Created by Taketo Yoshida on 17/3/20.
//  Copyright © 2020 Taketo Yoshida. All rights reserved.
//

#if os(Linux)
    import Glibc
#else
    import Foundation
    import Darwin
#endif

#if swift(<3.0)
extension String: CollectionType {}
#endif

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

prefix operator *
prefix func * <T> (a: [T]) -> (T, T) { return (a[0], a[1]) }
prefix func * <T> (a: [T]) -> (T, T, T) { return (a[0], a[1], a[2]) }

let (A, B) = *readInts()

print(max(A + B, A - B, A * B))
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

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

let res = Math.max(a-b, a*b, a+b)

if(res === 0)res = 0

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

namespace AtCoder.abc098 {

    export class Program {
        args: string[];

        constructor(args: string[]) {
            this.args = args;
        }

        /**
         * in
         * 3 1
         * out
         * 4
         */
        main(): void {
            const [a, b]: number[] = this.args[0].split(' ').map(Number);
            console.log(~~Math.max(...[a + b, a - b, a * b]));
        }
    }

}

const args = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const prg = new AtCoder.abc098.Program(args);
prg.main();
//  [typescript]
'use strict'

function main(input) {
  input = input
    .trim()
    .split(' ')
    .map(Number)
  // .split('\n')
  // .map(v => v.split(' ').map(Number))

  const [a, b] = input
  const ans = Math.max(...[a + b, a - b, a * b])

  console.log('%d', ans)
}
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 [A, B] = input[0].map(Number);

  return Math.max(Math.max(A + B, A - B), A * B);
};

console.log(main(read()));
//  [typescript]
import { readFileSync } from "fs";

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

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

  return Math.max(A + B, A - B, A * B);
};

console.log(main(read()));
//  [typescript]
function Main(input: string) {
  const lines = input.split('\n');
  const params = lines[0].split(' ');

  const a = parseInt(params[0]);
  const b = parseInt(params[1]);

  const max =
    [a + b, a - b, a * b]
      .reduce((m, n) => Math.floor(Math.max(m, n)));

  console.log(max);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
k,x=map(int,input().split())
if 500*k>=x:
    print('Yes')
else:
    print('No')
//  [python]
K,X= map(int,input().split())

print("Yes" if K*500 >= X else "No")
//  [python]
a, b = map(int, input().split())
print('Yes' if a*500 >= b else 'No')
//  [python]
s,t=input().split()
print (t+s)
//  [python]
K,X= map(int,input().split())

if 500*K >= X:
  print("Yes")
 else:
  print("No")
//  [python]
K,X= map(int,input().split())

if 500*X >= X:
  print("Yes")
 else:
  print("No")
//  [java]

import static java.lang.System.*;

import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {

	public void solve() {
		int K = nextInt();
		int X = nextInt();

		if(K*500 >= X){
			out.println("Yes");
		}else {
			out.println("No");
		}
	}

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

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

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

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

	private void skipUnprintable() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

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

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

	public int nextInt() {
		return (int) nextLong();
	}

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

	long gcd(long a, long b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	long lcm(long a, long b) {
		return a * b / gcd(a, b);
	}

	double sqrt(double x) {
		return Math.sqrt(x);
	}

	double pow(double x, double y) {
		return Math.pow(x, y);
	}

	public static void main(String[] args) {
		Main m = new Main();

		m.solve();
	}

}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] sa = br.readLine().split(" ");
		int k = Integer.parseInt(sa[0]);
		int x = Integer.parseInt(sa[1]);
		br.close();

		if (500 * k >= x) {
			System.out.println("Yes");
		} else {
			System.out.println("No");
		}
	}
}
//  [java]
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.StringTokenizer; 
import java.util.*;
  
public class Main {  
	static Map<List<Integer>, Integer> dp;
	static int n;
	static int min = Integer.MAX_VALUE;
    public static void main(String[] args) throws IOException { 
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
		StringTokenizer st = new StringTokenizer(br.readLine()); 
		int k = Integer.parseInt(st.nextToken());
		int n = Integer.parseInt(st.nextToken());
		if (500 * k >= n) {
			System.out.println("Yes");
		} else {
			System.out.println("No");
		}
	}
}
//  [java]
import java.util.*;
class Main{
  public static void main(String[] args){
  	int x = 0;
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    String S = sc.next();
    
    for(int i = 0; i < (N - 2); i++){
    	if( S.charAt(i) == 'A' && S.charAt(i+1) == 'B'){
        	if(S.charAt(i+2) == 'C'){
            	x += 1;
            }
          
        }
      
    }
    System.out.println(x);
  
  }
}
//  [java]
import java.util.*;
class Main{
  public static void main(String[] args){
  	int x = 0;
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    String S = sc.nextLine();
    
    for(int i = 0; i <= (N - 2); i++){
    	if( S.charAt(i).equals("a") && S.charAt(i).equals("b")){
        	if(S.charAt(i).equals("c")){
            	x += 1;
            }
        }
    }
    System.out.println(x);
  
  }
}
//  [java]
import java.util.*;
class Main{
  public static void main(String[] args){
  	int x = 0;
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    String S = sc.nextLine();
    
    for(int i = 0; i <= (N - 2); i++){
    	if( S.charAt(i).equals(a) && S.charAt(i).equals(b)){
        	if(S.charAt(i).equals(c)){
            	x += 1;
            }
        }
    }
    System.out.println(x);
  
  }
}
//  [cpp]
// Etavioxy
#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
#include<cmath>
#define il inline
#define ll long long
#define rep(i,s,t) for(register int i=(s);i<=(t);i++)
#define rev_rep(i,s,t) for(register int i=(s);i>=(t);i--)
#define each(i,u) for(int i=head[u];i;i=bow[i].nxt)
#define file(s) freopen(s".in" ,"r",stdin),freopen(s".out","w",stdout)
#define pt(x) putchar(x)
using namespace std;
il int ci(){
	register char ch;int f=1;
	while(!isdigit(ch=getchar()))f=ch=='-'?-1:1;
	register int x=ch^'0';
	while(isdigit(ch=getchar()))x=(x*10)+(ch^'0');
	return f*x;
}

//

int main(){
	int x=ci(), k=ci();
	puts(x*500>=k? "Yes":"No");
	return 0;
}
//  [cpp]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
   int K,X;
   scanf("%d %d",&K,&X);
   if(500*K >= X)printf("Yes\n");
   else printf("No\n");
   return 0;
}
//  [cpp]
#include<stdio.h>
int main()
{ 
int a,b;

scanf("%d %d",&a,&b);
if((500*a)>=b)
printf("Yes");
else printf("No");






return 0;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

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


/********************************************************************/
#define M1 1000000007	//Standard primes used in modulo operations
#define M2 998244353
#define PI 3.1415926536
const int INF = INT_MAX;
#define ll long long
#define pll pair<ll,ll>
#define REP(i, a, b) for(ll i=a;i<b;i++)
#define REPR(i, a, b) for(ll i=b-1;i>=a;i--)
#define forr(i, n) for(ll i=0;i<n;i++)
#define ff first
#define ss second
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define MT make_tuple
#define V(a) vector<a>
#define vi vector<ll>
#define endl '\n'
#define ce(ele) cout<<ele<<' '
#define cs(ele) cout<<ele<<'\n'
#define CASE(t) ll t; cin>>t; while(t--)
#define space ' '
#define yes cout<<"Yes"<<endl
#define no cout<<"No"<<endl

void FAST() {	//FAST Input Output, DONT use both scnaf,printf / cin,cout , Use any ONE system
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
}
ll gcd(ll x, ll y) {	//returns gcd of two long long ints
	if (x == 0) return y;
	return gcd(y % x, x);
}

ll powM(ll x, ll y, ll m) {	//returns (a^b)%m ( ^ is exponent )
	ll ans = 1, r = 1;
	x %= m;
	while (r > 0 && r <= y)
	{
		if (r & y)
		{
			ans *= x;
			ans %= m;
		}
		r <<= 1;
		x *= x;
		x %= m;
	}
	return ans;
}

map<long long, long long> factorize(long long n) {	//returns map containing factor and multiplicity, Eg: 60 = {{2,2},{3,1},{5,1}}
	map<long long, long long> ans;
	for (long long i = 2; i * i <= n; i++) {
		while (n % i == 0) {
			ans[i]++;
			n /= i;
		}
	}
	if (n > 1) {
		ans[n]++;
		n = 1;
	}
	return ans;
}
/* **********END OF TEMPLATE*********** */


int main() {
	ll k,x;
	cin>>k>>x;
	if(k*500>=x){
		cout<<"yes"<<endl;
	}
	else{
		cout<<"no"<<endl;
	}
	}
//  [cpp]
#include<iostream>
#include<algorithm>
#include<stdio.h>
using namespace std;
int main()
{
    int k,x;
    scanf("%d%d",&k,&x);
    if(k*500>=x){
        printf("Yes");
    }
    else{
        printf("NO");
    }
    return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int K,X;
  
  scanf("%d %d",&K,&X);
  
  
  
  if(K*500 >= X){
    printf("Yes\n");
  }
  else{
    printf("No\n");
  }
  
  return 0;
}
//  [c]
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<ctype.h>
#include<stdlib.h>
#define STR 10
int main(){
    int k,x;
    scanf("%d %d",&k,&x);
    if(500*k>=x){
        printf("Yes");
    }else{
        printf("No");
    }
    return 0;
}
//  [c]
#include<stdio.h>

int main()
{
  int k,x;

  scanf("%d",&k);
  scanf("%d",&x);

  if(k*500 >= x){
    printf("Yes");
  }
  else{
    printf("No");
  }

  return 0;
}
//  [c]
#include<stdio.h>
int main (){
	int k;
	int x;
	if (k*500>x) {
		printf ("Yes");
	}
	else  (k*500<x) {
		printf ("No");
	}
	
	return 0;
}
//  [c]
#include<stdio.h>
int main (){
	int k;
	int x;
	if (k*500>x) {
		printf ("Yes");
	}
	else if (k*500<x) {
		printf ("No");
	}
	
	return 0;
}
//  [c]
#include <stdio.h>

int main(){
    int k,x;
    scanf("%d %d",&k,&x);
    k*500>= 0 ? printf("Yes\n") : printf("No\n");
    return 0;
}
//  [javascript]
function Main(input) {
    input = input.split(" ");
    var k = input[0];
    var n = input[1];

    if (500*k >= n) {
        console.log("Yes");
    } else {
        console.log("No");
    }
  }
   
  Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  input = input.split(" ");
  
  var k = parseInt(input[0],10);
  var x = parseInt(input[1],10);
  
  if(k * 500 >= x){
    console.log("Yes");
  }
  else{
    console.log("No");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';
function main(input) {
  input = input.split(" ");
  const a = parseInt(input[0], 10);
  const b = parseInt(input[1], 10);
  
  console.log(500 * a >= b ? 'Yes' : 'No');
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
((stdin) => {
	const [k, x] = stdin.split(" ");
	if (500 * +k > +x) {
		console.log('Yes');
	}
	else {
		console.log('No');
	}
})(require('fs').readFileSync('/dev/stdin', 'UTF-8'))
//  [javascript]
((stdin) => {
	const [k, x] = stdin.split(" ");
	if (500 * k > x) {
		console.log('Yes');
	}
	else {
		console.log('No');
	}
})(require('fs').readFileSync('/dev/stdin', 'UTF-8'))
//  [javascript]
((stdin) => {
	const [n, s] = stdin.split('\n');
	let res = s.match(/ABC/g);
	if (res === null) {
		console.log(0);
	} else {
		console.log(res.length);
	}
})(require('fs').readFileSync('/dev/stdin', 'UTF-8'));
//  [go]
// +build ignore
package main

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

func solve(sc *scanner, wr *bufio.Writer) int {
	K := sc.i()
	X := sc.i()

	if 500*K >= X {
		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"
	"math"
	"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 maxFloat64(a, b float64) float64 {
	if a > b {
		return a
	} else {
		return b
	}
}

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
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

//Main
const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		return sc
	}()
)

var k, x int

func main() {
	sc.Split(bufio.ScanWords)
	k, x = nextInt(), nextInt()

	if k*500 >= x {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}

}
//  [go]
package main

import "fmt"

func main() {
	var k, x int
	fmt.Scan(&k, &x)
	if k*500 >= x {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

fpackage main

import (
	"fmt"
)

func main() {
	var k, x int
	fmt.Scan(&k, &x)

	if 500*k >= x {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var k, x int
	fmt.Scanf("%d %d", &k, &x)

	if 500 * k >= x {
		fmt.Print("Yes\n")
	} else {
		fmt.Print("NG\n")
	}
}
//  [go]
package main

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

const (
	initialBufSize = 64 * 1024
	maxBufSize     = 10000000
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	// writer  = bufio.NewWriter(os.Stdout)
)

func main() {
	// scanner.Buffer(make([]byte, maxBufSize), maxBufSize)
	scanner.Split(bufio.ScanWords)
	k, x := scanInt(), scanInt()

	if (k * 500) >= x {
		fmt.Print("Yes")
	} else {
		fmt.Print("No")
	}
}

func scanInt() int {
	i, _ := strconv.Atoi(scanText())
	return i
}

func scanInts(size int) []int {
	ints := make([]int, size)
	for i := 0; i < size; i++ {
		ints[i] = scanInt()
	}
	return ints
}

func scanText() string {
	scanner.Scan()
	return scanner.Text()
}

func abs(n int) int {
	return int(math.Abs(float64(n)))
}

func pow(x, y int) int {
	return int(math.Pow(float64(x), float64(y)))
}

func reverse(s string) string {
	b := *(*[]byte)(unsafe.Pointer(&s))
	return string(reverseByte(b))
}

func reverseByte(b []byte) []byte {
	for i, j := 0, (len(b) - 1); i < j; i, j = i+1, j-1 {
		b[i], b[j] = b[j], b[i]
	}
	return b
}
package main

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

const (
	initialBufSize = 64 * 1024
	maxBufSize     = 10000000
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	// writer  = bufio.NewWriter(os.Stdout)
)

func main() {
	// scanner.Buffer(make([]byte, maxBufSize), maxBufSize)
	scanner.Split(bufio.ScanWords)
	k, x := scanInt(), scanInt()

	if (k * 500) >= x {
		fmt.Print("Yes")
	} else {
		fmt.Print("No")
	}
}

func scanInt() int {
	i, _ := strconv.Atoi(scanText())
	return i
}

func scanInts(size int) []int {
	ints := make([]int, size)
	for i := 0; i < size; i++ {
		ints[i] = scanInt()
	}
	return ints
}

func scanText() string {
	scanner.Scan()
	return scanner.Text()
}

func abs(n int) int {
	return int(math.Abs(float64(n)))
}

func pow(x, y int) int {
	return int(math.Pow(float64(x), float64(y)))
}

func reverse(s string) string {
	b := *(*[]byte)(unsafe.Pointer(&s))
	return string(reverseByte(b))
}

func reverseByte(b []byte) []byte {
	for i, j := 0, (len(b) - 1); i < j; i, j = i+1, j-1 {
		b[i], b[j] = b[j], b[i]
	}
	return b
}
//  [ruby]
# 入力
k,x = gets.chomp.split.map(&:to_i)

# こたえ
if 500 * k >= x
  puts "Yes"
else
  puts "No"
end
//  [ruby]
k,x = gets.split().map(&:to_i)
if k * 500 >= x
  puts "Yes"
else
  puts "No"
end
//  [ruby]
K,X=gets.split.map(&:to_i)
puts (500*K>=X ? "Yes":"No")
//  [ruby]
k,x=gets.split.map &:to_i
p k*500<x ? :No : :Yes
//  [ruby]
K=gets.to_i
X=gets.to_i

if X<=500*K
  puts "Yes"
else
  puts "No"
end
//  [ruby]
K = gets.to_i
X = gets.to_i

if X <= 500*K
  puts "Yes"
else
  puts "No"
end
//  [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! {
        k: u32,
        x: u32
    }
    println!("{}", if x <= 500 * k {"Yes"} else {"No"});
}
/* vim:set foldmethod=marker: */
//  [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 k:u32 = match iter.next().unwrap().parse() {
		Ok(m) => m,
		Err(_) => panic!(""),
	};
	let x:u32 = match iter.next().unwrap().parse() {
		Ok(m) => m,
		Err(_) => panic!(""),
	};
	if 500*k >= x {
		println!("Yes");
	}else{
		println!("No");
	}
}
//  [rust]
use proconio::input;
 
fn main() {
  input! {
    K: i32,
    X: i32,
  }
  println!(if 500 * K >= X { "Yes" } else { "No" });
}
//  [rust]
use proconio::input;
 
fn main() {
  input! {
    K: i32,
    X: i32,
  }
  println!("{}", if 100 * K >= X { "Yes" } else { "No" });
}
//  [rust]
use proconio::input;

fn main() {
  input! {
    K: i32,
    X: i32,
  }
  println!(if 100 * K >= X { "Yes" } else { "No" });
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let a = readInts()
let b = a[0]
let c = a[1]
if 500*b>=c {
  print("Yes")
} else {
  print("No")
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

let num=readInts()
if(num[1]-500*num[0]>0){print("No")}else{print("Yes")}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
    
let kx = readInts()
let k = kx[0]
let x = kx[1]
let a=500*k-x
if a>=0{
  print("Yes")
}else{
  print("No")
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
    
let kx = readInts()
let k = kx[0]
let x = kx[1]
let a=500*k-x
if a>0{
  print("Yes")
}else{
  print("No")
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
    
let kx = readInts()
let k = kx[0]
let x = kx[1]
a=500*k-x
if a>0{
  print("Yes")
}else{
  print("No")
}
//  [swift]
extension String: CollectionType {} 
a: [Int] = readLine()!.split(" ").map { Int($0)! }
var nums:Int = 500 * a[0] //枚数
var pri:Int = a[1] //値段
if nums < pri{
	print("No")
}else{
	print("Yes")
}
//  [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 [k, x] = input[0].split(' ').map((x: string): number => +x);

if (k*500 >= x){
	console.log('Yes');
}else{
	console.log('No');
}
//  [typescript]
export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [k, x]: number[] = tmp[0].split(" ").map(int => parseInt(int));
    return `${500 * k >= x ? "Yes" : "No"}`;
  }
}
console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const ceil=(a)=>{return Math.ceil(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};const gcd=(x,y)=>{while(y){[x,y]=[y,x%y]}return x};const sum=(arr)=>{return arr.reduce((a,b)=>a+b);};const 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;};
const main=()=>{
  to(tn()*500>=tn()?'Yes':'No')
}
main()
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const ceil=(a)=>{return Math.ceil(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};const gcd=(x,y)=>{while(y){[x,y]=[y,x%y]}return x};const sum=(arr)=>{return arr.reduce((a,b)=>a+b);};const 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;};
const main=()=>{
  to(tn()*500>tn()?'Yes':'No')
}
main()
//  [python]
# -*- coding: utf-8 -*-

tmp = input()
x, a, b = [int(a) for a in tmp.split()]

d1 = abs(x - a)
d2 = abs(x - b)

print("A" if d1 < d2 else "B")
//  [python]
def main():
    X, A, B = map(int, input().split())

    if abs(A - X) < abs(B - X):
        ans = 'A'
    else:
        ans = 'B'
    print(ans)

main()
//  [python]
x,a,b = map(int,input().split())
print("A" if abs(x-a)<abs(x-b) else "B")
//  [python]
a,b,c = map(int,input().split())

if abs(a-b) > abs(a-c):
    print('A')
else:
    print('B')
//  [python]
x , a , b = map(int,input().split())
if abs(x-a) > abs(x-b):
    print("A")
else:
    print("B")
//  [python]
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
  print(a)
else:
  print(b)
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String x = br.readLine();
		String[] cut = x.split(" ");

		int a = Integer.parseInt(cut[0]);
		int b = Integer.parseInt(cut[1]);
		int c = Integer.parseInt(cut[2]);

		System.out.println(Math.abs(a - b) <= Math.abs(a - c) ? "A" : "B");
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) throws Exception {
		String line = readLine();
		String[] strArray = line.split(" ");
		int[] array = new int[strArray.length];
		for(int i = 0; i < array.length; i++ ) {
			array[i] = Integer.parseInt(strArray[i]);
		}
		int distanceA = Math.abs(array[0] - array[1]);
		int distanceB = Math.abs(array[0] - array[2]);
		if(distanceA < distanceB) {
			System.out.println("A");
		} else {
			System.out.println("B");
		}
	}


	private static String readLine() throws Exception {
		BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
		return br.readLine();
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws Exception {
		String line = readLine();
		String[] strArray = line.split(" ");
		int[] array = new int[strArray.length];
		for(int i = 0; i < array.length; i++ ) {
			array[i] = Integer.parseInt(strArray[i]);
		}
		int distanceA = Math.abs(array[0] - array[1]);
		int distanceB = Math.abs(array[0] - array[2]);
		if(distanceA < distanceB) {
			System.out.println("A");
		} else {
			System.out.println("B");
		}
	}


	private static String readLine() throws Exception {
		BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
		return br.readLine();
	}
}