use std::cmp::max;
use std::collections::HashMap;

fn read<T: std::str::FromStr>(
    stdin_lock: &mut std::io::StdinLock,
    buf: &mut Vec<u8>,
    delimiter: u8,
) -> T {
    buf.clear();
    let l = std::io::BufRead::read_until(stdin_lock, delimiter, buf).unwrap();
    buf.truncate(l - 1); // remove delimiter
    let s = unsafe { std::str::from_utf8_unchecked(&buf) };
    s.parse().unwrap_or_else(|_| panic!("read"))
}

fn main() {
    let stdin = std::io::stdin();
    let mut stdin_lock = stdin.lock();
    let mut buf: Vec<u8> = Vec::new();
    let n: usize = read(&mut stdin_lock, &mut buf, b'\n');
    let mut map: HashMap<String, i32> = HashMap::new();
    for _ in 0..n {
        let k: String = read(&mut stdin_lock, &mut buf, b'\n');
        let v: i32 = *map.get(&k).unwrap_or(&0);
        map.insert(k, v + 1);
    }
    let m: usize = read(&mut stdin_lock, &mut buf, b'\n');
    for _ in 0..m {
        let k: String = read(&mut stdin_lock, &mut buf, b'\n');
        match map.get(&k) {
            Some(&v) => map.insert(k, v - 1),
            None => None,
        };
    }

    let max_key = map.keys().max_by_key(|&k| map.get(k).unwrap()).unwrap();
    let ans = max(map.get(max_key).unwrap(), &0);
    println!("{}", ans);
}


import Foundation

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

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

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = readInt()!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

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

let N = readInt()!
var blue = [String : Int]()
for _ in 0..<N {
    let s = readLine()!
    if blue[s] == nil {
        blue[s] = 1
    } else {
        blue[s] = blue[s]! + 1
    }
}
let M = readInt()!
var red = [String : Int]()
for _ in 0..<M {
    let s = readLine()!
    if red[s] == nil {
        red[s] = 1
    } else {
        red[s] = red[s]! + 1
    }
}
var ans = 0
for (s, _) in blue {
    ans = max(blue[s]! - (red[s] ?? 0), ans)
}
print(ans)


var b=[String:Int]()
for _ in 0..<Int(readLine()!)!{
    let s=readLine()!
    b[s]=(b[s] ?? 0)+1
}
var r=[String:Int]()
for _ in 0..<Int(readLine()!)!{
    let t=readLine()!
    r[t]=(r[t] ?? 0)+1
}
var ans=0
for (s,_) in b{
    ans=max(b[s]!-(r[s] ?? 0),ans)
}
print(ans)


var b=["":0]
for _ in 0..<Int(readLine()!)!{
    let s=readLine()!
    b[s]=(b[s] ?? 0)+1
}
for _ in 0..<Int(readLine()!)! {
    let t=readLine()!
    b[t]=(b[t] ?? 0)-1
}
print(b.sort{$0.1>$1.1}[0].1)


var b=["":0]
for _ in 0..<Int(readLine()!)!{
    let s=readLine()!
    b[s]=(b[s] ?? 0)+1
}
for _ in 0..<Int(readLine()!)! {
    let t=readLine()!
    b[t]=(b[t] ?? 0)-1
}
print(b.sort{$0.1>$1.1}[0].value)


var b=["":0]
for _ in 0..<Int(readLine()!)!{
    let s=readLine()!
    b[s]=(b[s] ?? 0)+1
}
for _ in 0..<Int(readLine()!)! {
    let t=readLine()!
    b[t]=(b[t] ?? 0)-1
}
print(b.sort{$0.value>$1.value}[0].value)


var b=["":0]
for _ in 0..<Int(readLine()!)!{
    let s=readLine()!
    b[s]=(b[s] ?? 0)+1
}
for _ in 0..<Int(readLine()!)! {
    let t=readLine()!
    b[t]=(b[t] ?? 0)-1
}
print(b.max{$0.value<$1.value}!.value)


import * as fs from 'fs';

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

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

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

        main(this: TaskB): void {
            const n: number = parseInt(this.args[0][0], 10);
            const m: number = parseInt(this.args[n + 1][0], 10);
            const map = new Map;

            for (let i = 0; i < n; i++) {
                const key: string = this.args[i + 1][0];
                if (!map.has(key)) {
                    map.set(key, 0);
                }
                map.set(key, 1 + map.get(key))
            }

            for (let i = 0; i < m; i++) {
                const key: string = this.args[n + i + 2][0];
                if (!map.has(key)) {
                    map.set(key, 0);
                }
                map.set(key, -1 + map.get(key));
            }

            const array: number[] = [];
            map.forEach((value) => {
                array.push(value);
            });

            const ans: number = Math.max(...array);
            console.log(ans > 0 ? ans : 0);
        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(x => x.split(' '));
    const task: AtCoder.Task = new TaskB(args);
    task.main();
}


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

const n = Number(stdin.split('\n')[0])
const s = stdin.split('\n').slice(1, n + 1)
const m = Number(stdin.split('\n')[n + 1])
const t = stdin.split('\n').slice(n + 2, n + 2 + m)

const getTotal = str => {
  let total = 0
  for (let i = 0; i < n; i++) {
    if (s[i] === str) {
      total++
    }
  }

  for (let i = 0; i < m; i++) {
    if (t[i] === str) {
      total--
    }
  }

  return total
}

const ans = () => {
  const totals = s.map(str => getTotal(str))

  const max = Math.max(...totals)

  return max < 0 ? 0 : max
}

console.log(ans())


const log = console.log;

const createScanFunctions = (input: string) => {
  const str = input.trim();
  const len = str.length;
  let index = 0;

  const scan = () => {
    const startIndex = index;

    while (index < len) {
      const char = str[index];

      if (char === " " || char === "\n")
        return str.substring(startIndex, index++);

      index++;
    }

    return str.substr(startIndex);
  };

  const scanInt = () => parseInt(scan());

  return { scan, scanInt };
};

// ----

function addMappedValue<T>(map: Map<T, number>, key: T, v: number) {
  map.set(key, (map.get(key) || 0) + v);
}

// ----

function Main(input: string): void {
  const { scan, scanInt } = createScanFunctions(input);

  const wordPointMap = new Map<string, number>();

  const n = scanInt();

  for (let i = 0; i < n; i++) addMappedValue(wordPointMap, scan(), 1);

  const m = scanInt();

  for (let i = 0; i < m; i++) addMappedValue(wordPointMap, scan(), -1);

  log(Math.max(0, ...Array.from(wordPointMap.values())));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}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 asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.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 vrk=(arr)=>{const a=[];for(const v of arr){a.push(v)}return a};
const main=()=>{
  let o={}
  let n=tn()
  let na=tss(n)
  for(let i=0;i<n;i++)o[na[i]]=0
  let m=tn()
  let ma=tss(m)
  for(let i=0;i<m;i++)o[ma[i]]=0
  for(let i=0;i<n;i++)o[na[i]]+=1
  for(let i=0;i<m;i++)o[ma[i]]-=1
  to(max(...vrk(o))<0?0:max(...vrk(o)))
}
main()


const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}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 asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.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 main=()=>{
  let o={}
  let n=tn()
  let na=tss(n)
  for(let i=0;i<n;i++)o[na[i]]=0;
  let m=tn()
  let ma=tss(m)
  for(let i=0;i<m;i++)o[ma[i]]=0;
  for(let i=0;i<n;i++)o[na[i]]+=1
  for(let i=0;i<m;i++)o[ma[i]]-=1
  to(max(...Object.values(o))<0?0:max(...Object.values(o)))
}
main()


const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}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 asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.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 main=()=>{
  let o={}
  let n=tn()
  let na=tss(n)
  for(let i=0;i<n;i++)o[na[i]]=0;
  let m=tn()
  let ma=tss(m)
  for(let i=0;i<m;i++)o[ma[i]]=0;
  for(let i=0;i<n;i++)o[na[i]]+=1
  for(let i=0;i<m;i++)o[ma[i]]-=1
  to(max(...Object.values(o)))
}
main()


A, B = map(int, input().split())
print (max(A+B, A-B, A*B))


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

print(max(A+B,A-B,A*B))


a,b=map(int,input().split())
print(max(a+b,a-b,a*b))


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)


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)


a,b=map(int,input().split())
print(max(a+b,a=b,a*b))


import java.io.*;

public class Main {
	private static final int mod = (int) 1E9 + 7, bufsize = (1 << 13);
	private static int iNextByte, iNextIndex, iReadByteCount, oNextIndex;
	private static final byte ibuf[] = new byte[bufsize], obuf[] = new byte[bufsize];
	private static InputStream input = System.in;
	private static OutputStream output = System.out;
	private static PrintStream err = System.err;

	private Main() throws Exception {
		if (local) input = new FileInputStream(new File("").getAbsolutePath() + "/src/zzz_input");
		if (local) output = new FileOutputStream(new File("").getAbsolutePath() + "/src/zzz_output");
		readByte();
		solve();
		input.close();
		flushOutBuf();
	}

	public static void main(String[] args) {
		try {
			new Main();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private int readByte() throws IOException {
		if (iNextIndex >= iReadByteCount) {
			iReadByteCount = input.read(ibuf, 0, bufsize);
			if (iReadByteCount == -1) return (iNextByte = -1);
			iNextIndex = 0;
		}
		return (iNextByte = ibuf[iNextIndex++]);
	}

	private char nc() throws IOException {
		while (iNextByte <= ' ') readByte();
		char res = (char) iNextByte;
		readByte();
		return res;
	}

	private int ni() throws IOException {
		int res = 0;
		while (iNextByte <= ' ') readByte();
		boolean minus = (iNextByte == '-');
		if (minus) readByte();
		if (iNextByte < '0' || iNextByte > '9') throw new RuntimeException();
		do {res = (res << 1) + (res << 3) + iNextByte - '0';} while (readByte() >= '0' && iNextByte <= '9');
		return minus ? -res : res;
	}

	private long nl() throws IOException {
		long res = 0;
		while (iNextByte <= ' ') readByte();
		boolean minus = (iNextByte == '-');
		if (minus) readByte();
		if (iNextByte < '0' || iNextByte > '9') throw new RuntimeException();
		do {res = (res << 1) + (res << 3) + iNextByte - '0';} while (readByte() >= '0' && iNextByte <= '9');
		return minus ? -res : res;
	}

	private double nd() throws IOException {
		double pre = 0.0, suf = 0.0, div = 1.0;
		while (iNextByte <= ' ') readByte();
		boolean minus = (iNextByte == '-');
		if (minus) readByte();
		if (iNextByte < '0' || iNextByte > '9') throw new RuntimeException();
		do {pre = 10 * pre + (iNextByte - '0');} while (readByte() >= '0' && iNextByte <= '9');
		if (iNextByte == '.') while (readByte() >= '0' && iNextByte <= '9') suf += (iNextByte - '0') / (div *= 10);
		return minus ? -(pre + suf) : (pre + suf);
	}

	private String ns() throws IOException {
		while (iNextByte <= ' ') readByte();
		StringBuilder sb = new StringBuilder();
		while (iNextByte > ' ') {
			sb.append((char) iNextByte);
			readByte();
		}
		return sb.toString();
	}

	private char[] nc(int n) throws IOException {
		char a[] = new char[n];
		for (int i = 0; i < n; ++i) a[i] = nc();
		return a;
	}

	private char[][] nc(int r, int c) throws IOException {
		char a[][] = new char[r][c];
		for (int i = 0; i < r; ++i) a[i] = nc(c);
		return a;
	}

	private int[] ni(int n) throws IOException {
		int a[] = new int[n];
		for (int i = 0; i < n; ++i) a[i] = ni();
		return a;
	}

	private int[][] ni(int r, int c) throws IOException {
		int a[][] = new int[r][c];
		for (int i = 0; i < r; ++i) a[i] = ni(c);
		return a;
	}

	private long[] nl(int n) throws IOException {
		long a[] = new long[n];
		for (int i = 0; i < n; ++i) a[i] = nl();
		return a;
	}

	private long[][] nl(int r, int c) throws IOException {
		long a[][] = new long[r][c];
		for (int i = 0; i < r; ++i) a[i] = nl(c);
		return a;
	}

	private double[] nd(int n) throws IOException {
		double a[] = new double[n];
		for (int i = 0; i < n; ++i) a[i] = nd();
		return a;
	}

	private double[][] nd(int r, int c) throws IOException {
		double a[][] = new double[r][c];
		for (int i = 0; i < r; ++i) a[i] = nd(c);
		return a;
	}

	private String[] ns(int n) throws IOException {
		String a[] = new String[n];
		for (int i = 0; i < n; ++i) a[i] = ns();
		return a;
	}

	private String[][] ns(int r, int c) throws IOException {
		String a[][] = new String[r][c];
		for (int i = 0; i < r; ++i) a[i] = ns(c);
		return a;
	}

	private void flushOutBuf() {
		try {
			if (oNextIndex <= 0) return;
			output.write(obuf, 0, oNextIndex);
			output.flush();
			oNextIndex = 0;
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private <T> void print(T ob) {
		String s = ob + "";
		for (int i = 0, N = s.length(); i < N; ++i) {
			obuf[oNextIndex++] = (byte) s.charAt(i);
			if (oNextIndex >= bufsize) flushOutBuf();
		}
	}

	private <T> void println(T ob) {
		print(ob + "\n");
	}

	private <T> void debug(T obj) {
		err.print(obj);
	}

	private <T> void debugln(T obj) {
		err.println(obj);
	}

	private static final boolean local = false;

	private void solve() throws Exception {
		int A = ni(), B = ni();
		int ans = Math.max(A + B, A - B);
		println(Math.max(ans, A * B));
	}
}


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

public class Main {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int A = sc.nextInt();
		int B = sc.nextInt();
System.out.println(Math.max(A+B, Math.max(A-B, A*B)));

	}

	//以下、自作ライブラリ

	/*
		int N = sc.nextInt();

		int[] a = new int[N];
		for (int i = 0; i < N; i++)
			a[i] = sc.nextInt();

		String s = sc.next();

		String[] a = new String[N];
		for (int i = 0; i < N; i++)
			a[i] = sc.next();
	 */

	//階乗
	public static int fact(int n) {
		if (n == 1 || n == 0)
			return 1;
		else
			return n * fact(n - 1);
	}

	//指定した値以上の要素が最初に現れる位置
	//要素の数は+1（配列のズレ)
	public static long lowerBound(int n, long[] x, long y) {
		int left = 0;
		int right = n;
		while (left < right) {
			int mid = (left + right) / 2;
			if (x[mid] < y) {
				left = mid + 1;
			} else {
				right = mid;
			}
		}
		return left;
	}

	//指定した値より大きい要素が最初に現れる位置
	//要素の数は+1（配列のズレ)
	public static long upperBound(int n, long[] x, long y) {
		int left = 0;
		int right = n;
		while (left < right) {
			int mid = (left + right) / 2;
			if (x[mid] <= y) {
				left = mid + 1;
			} else {
				right = mid;
			}
		}
		return left;
	}

	//最大公約数
	public static long gcd(long a, long b) {
		if (a < b)
			return gcd(b, a);
		long c = 0;
		c = a % b;
		if (c == 0)
			return b;
		return gcd(b, c);
	}

	//最小公倍数
	public static long lcm(long m, long n) {
		return m * n / gcd(m, n);
	}

	//素数判定
	public static boolean isPrime(int n) {
		if (n < 2)
			return false;
		if (n == 2)
			return true;
		if (n % 2 == 0)
			return false;

		for (int i = 3; i * i <= n; i += 2) {
			if (n % i == 0)
				return false;
		}
		return true;
	}
}

//以下、高速スキャナークラス
class FastScanner {
	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;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		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() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	}

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


import java.io.*;
import java.util.*;

class FastScanner {
    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;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; 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() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() { return Double.parseDouble(next());}
}

class Main{

    static FastScanner scan = new FastScanner();
    static final int MOD = 1_000_000_007;
    static final int INF = 2147483647;
    static final long LINF = 9223372036854775807L;

    // Scanner
    int ni(){
        return scan.nextInt();
    }
    int[] ni(int n){int[] a = new int[n]; for(int i = 0; i < n; i++){a[i] = ni();} return a;}
    int[][] ni(int y, int x){int[][] a = new int[y][x];
        for(int i = 0; i < y; i++){for(int j = 0; j < x; j++){a[i][j] = ni();}} return a;}
    long nl(){return scan.nextLong();}
    long[] nl(int n){long[] a = new long[n]; for(int i = 0; i < n; i++){a[i] = nl();} return a;}
    long[][] nl(int y, int x){long[][] a = new long[y][x];
        for(int i = 0; i < y; i++){for(int j = 0; j < x; j++){a[i][j] = nl();}} return a;}
    String ns(){return scan.next();}
    String[] ns(int n){String[] a = new String[n]; for(int i = 0; i < n; i++){a[i] = ns();} return a;}
    String[][] ns(int y, int x){String[][] a = new String[y][x];
        for(int i = 0; i < y; i++){for(int j = 0; j < x; j++){a[i][j] = ns();}} return a;}

    // Math
    int max(int a, int b){return Math.max(a, b);}
    long max(long a, long b){return Math.max(a, b);}
    double max(double a, double b){return Math.max(a, b);}
    int max(int[] a){int max = a[0]; for(int value:a){max = max(max,value);} return max;}
    long max(long[] a){long max = a[0]; for(long value:a){max = max(max,value);} return max;}
    double max(double[] a){double max = a[0]; for(double value:a){max = max(max,value);} return max;}
    int min(int a, int b){return Math.min(a, b);}
    long min(long a, long b){return Math.min(a, b);}
    double min(double a, double b){return Math.min(a, b);}
    int min(int[] a){int min = a[0]; for(int value:a){min = min(min,value);} return min;}
    long min(long[] a){long min = a[0]; for(long value:a){min = min(min,value);} return min;}
    double min(double[] a){double min = a[0]; for(double value:a){min = min(min,value);} return min;}
    long sum(int[] a){long sum = 0; for(int value:a){sum += value;} return sum;}
    long sum(long[] a){long sum = 0; for(long value:a){sum += value;} return sum;}
    double sum(double[] a){double sum = 0; for(double value:a){sum += value;} return sum;}
    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);}
    int lcm(int a, int b){return a / gcd(a, b) * b;}
    long lcm(long a, long b){return a / gcd(a, b) * b;}
    long fact(int n){ if(n == 0){ return 1; } long a = n; for(long i = n - 1; i >= 2; i--){ a *= i; } return a; }
    long fact(long n){ if(n == 0){ return 1; } long a = n; for(long i = n - 1; i >= 2; i--){ a *= i; } return a; }
    long ncr(int n, int r){
        long a = 1;
        for(int i = n; i > n - r; i--){
            a *= i;
        }
        long b = fact(r);
        return a / b;
    }
    long ncr(long n, long r){
        long a = 1;
        for(long i = n; i > n - r; i--){
            a *= i;
        }
        long b = fact(r);
        return a / b;
    }
    long npr(int n, int r){
        long a = 1;
        for(int i = n; i > n - r; i--){
            a *= i;
        }
        return a;
    }
    long npr(long n, long r){
        long a = 1;
        for(long i = n; i > n - r; i--){
            a *= i;
        }
        return a;
    }

    // Array
    void sort(int[] a){ Arrays.sort(a);}
    void sort(long[] a){ Arrays.sort(a);}
    void sort(double[] a){ Arrays.sort(a);}
    void sort(String[] a){ Arrays.sort(a);}
    int[] reverse(int[] a){
        int[] reversed = new int[a.length];
        for(int i = 0; i < a.length; i++){
            reversed[a.length - i - 1] = a[i];
        }
        return reversed;
    }
    long[] reverse(long[] a){
        long[] reversed = new long[a.length];
        for(int i = 0; i < a.length; i++){
            reversed[a.length - i - 1] = a[i];
        }
        return reversed;
    }
    double[] reverse(double[] a){
        double[] reversed = new double[a.length];
        for(int i = 0; i < a.length; i++){
            reversed[a.length - i - 1] = a[i];
        }
        return reversed;
    }
    char[] reverse(char[] a){
        char[] reversed = new char[a.length];
        for(int i = 0; i < a.length; i++){
            reversed[a.length - i - 1] = a[i];
        }
        return reversed;
    }
    String[] reverse(String[] a){
        String[] reversed = new String[a.length];
        for(int i = 0; i < a.length; i++){
            reversed[a.length - i - 1] = a[i];
        }
        return reversed;
    }
    boolean[] reverse(boolean[] a){
        boolean[] reversed = new boolean[a.length];
        for(int i = 0; i < a.length; i++){
            reversed[a.length - i - 1] = a[i];
        }
        return reversed;
    }
    void fill(int[] array, int x) { Arrays.fill(array, x); }
    void fill(long[] array, long x) { Arrays.fill(array, x); }
    void fill(double[] array, double x) { Arrays.fill(array, x); }
    void fill(boolean[] array, boolean x) { Arrays.fill(array, x); }
    void fill(int[][] array, int x) { for(int a[] : array) { fill(a, x); } }
    void fill(long[][] array, long x) { for(long a[] : array) { fill(a, x); } }
    void fill(double[][] array, double x) { for(double a[] : array) { fill(a, x); } }
    void fill(boolean[][] array, boolean x) { for(boolean a[] : array) { fill(a, x); } }

    public void solve(){
        int a = ni();
        int b = ni();
        System.out.println(max(a + b, max(a - b, a * b)));

    }
    public static void main(String[] args){
         new Main().solve();
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class AAddSubMul {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int a = in.nextInt();
            int b = in.nextInt();
            int x = a + b;
            int y = a - b;
            int z = a * b;
            if (x > y && x > z) {
                out.println(x);
            } else if (y > x && y > z) {
                out.println(y);
            } else if (z > x && z > y) {
                out.println(z);
            } else if (x == y && y == z && z == x) {
                out.println(x);
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class AAddSubMul {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int a = in.nextInt();
            int b = in.nextInt();
            int x = a + b;
            int y = a - b;
            int z = a * b;
            if (x > y && x > z) {
                out.println(x);
            } else if (y > x && y > z) {
                out.println(y);
            } else if (z > x && z > y) {
                out.println(z);
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class AAddSubMul {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int a = in.nextInt();
            int b = in.nextInt();
            int x = a + b;
            int y = a - b;
            int z = a * b;
            if (x > y && x > z) {
                out.println(x);
            } else if (y > x && y > z) {
                out.println(y);
            } else {
                out.println(z);
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }
}


#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);
}


#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;
}


#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;
   }


#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;
}


#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;

}


#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;
}


#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;
}


#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;
}


#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');
}


#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);
}


#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);
}


#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;
}


// 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"));


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"));


// 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"))


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"))


let [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(" ").map(Number);
console.log(Math.max(a + b, a - b, a * b));


package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"math"
	"os"
	"strconv"
)

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)
		sc.Split(bufio.ScanWords)
		return sc
	}()
)

func main() {
	A := getInt()
	B := getInt()

	fmt.Println(max(A+B, A-B, A*B))
}

type Graph struct {
	n     int
	edges [][]int
}

func NewGraph(n int) *Graph {
	g := &Graph{
		n:     n,
		edges: make([][]int, n),
	}
	return g
}

func (g *Graph) AddEdge(u, v int) {
	g.edges[v] = append(g.edges[v], u)
	g.edges[u] = append(g.edges[u], v)
}

func dfs(c int, edges [][]int, visited map[int]struct{}) {
	visited[c] = struct{}{}

	for _, v := range edges[c] {
		_, flag := visited[v]
		if flag {
			continue
		}
		dfs(v, edges, visited)
	}
}

func bfs(c int, graph *Graph) {
	next := make([]int, 0)
	next = append(next, c)
	visited := make(map[int]struct{})

	for ; len(next) != 0; {
		u := next[0]
		next = next[1:]
		visited[u] = struct{}{}

		for _, v := range graph.edges[u] {
			_, flag := visited[v]
			if flag {
				continue
			}

			// なにか処理

			next = append(next, v)
		}
	}
}

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

func getIntArray(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = getInt()
	}
	return array
}

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

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

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

func powMod(n, p int) int {
	if p == 0 {
		return 1
	} else if p%2 == 0 {
		t := powMod(n, p/2)
		return calcMod(t * t)
	} else {
		return calcMod(n * powMod(n, p-1))
	}
}

func min(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton min() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Min(float64(res), float64(nums[i])))
	}
	return res
}

func max(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton max() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Max(float64(res), float64(nums[i])))
	}
	return res
}

func strSearch(a []string, b string) bool {
	for i := 0; i < len(a); i++ {
		if a[i] == b {
			return true
		}
	}
	return false
}

func printIntArray(array []int) {
	strArray := fmt.Sprint(array)
	fmt.Println(strArray[1 : len(strArray)-1])
}

func calcMod(x int) int {
	return x % mod
}

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 isPrime(n int) bool {
	if n < 2 {
		return false
	} else if n == 2 {
		return true
	} else if n % 2 == 0 {
		return false
	}

	sqrtN := int(math.Sqrt(float64(n)))
	for i := 3; i <= sqrtN; i += 2 {
		if n % i == 0 {
			return false
		}
	}

	return true
}

func contains(s []int, e int) bool {
	for _, v := range s {
		if e == v {
			return true
		}
	}
	return false
}

func makeRange(min, max int) []int {
	a := make([]int, max-min+1)
	for i := range a {
		a[i] = min + i
	}
	return a
}

func powerset2(nums []int) [][]int {
	length := int(math.Pow(2, float64(len(nums))))
	result := make([][]int, length)

	index := 0
	result[index] = []int{}
	index++

	for _, n := range nums {
		max := index
		for i := 0; i < max; i++ {
			result[index] = copyAndAppend(result[i], n)
			index++
		}
	}

	return result
}

func copyAndAppend(nums []int, n int) []int {
	dst := make([]int, len(nums)+1)
	copy(dst, nums)
	dst[len(nums)] = n
	return dst
}

func calcGcd(x, y int) int {
	if y == 0 {
		return x
	} else if x >= y {
		return calcGcd(y, x % y)
	} else {
		return calcGcd(x, y % x)
	}
}

func getDivisor(n int) []int {
	var divisor []int
	divisor = append(divisor, 1)
	if n != 1 {
		divisor = append(divisor, n)
	}

	sqrt := int(math.Sqrt(float64(n)))
	for i := 2; i <= sqrt; i++ {
		if n % i == 0 {
			divisor = append(divisor, i)
			divisor = append(divisor, n/i)
		}
	}
	return divisor
}

type intHeap []int

func (h intHeap) Len() int {
	return len(h)
}

func (h intHeap) Less(i, j int) bool {
	return h[i] > h[j]
}

func (h intHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *intHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *intHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func initHeap() *intHeap {
	ih := &intHeap{}
	heap.Init(ih)
	return ih
}

func (h *intHeap) pushHeap(n int) {
	heap.Push(h, n)
}

func (h *intHeap) popHeap() int {
	return heap.Pop(h).(int)
}

func factMod(n int) int {
	value := 1
	for ; n > 1; n-- {
		value = calcMod(value * n)
	}
	return value
}

func combinationMod(n, k int) int {
	factN := factMod(n)
	factK := factMod(k)
	factNK := factMod(n - k)
	factKR := powMod(factK, mod - 2)
	factNKR := powMod(factNK, mod - 2)
	return calcMod(factN * calcMod(factKR * factNKR))
}


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)
}


// きりみんちゃんの配信からきました
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
}


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))
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b float64
	fmt.Println(math.Max(math.Max(a+b, a-b), a*b))
}


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)
}


a, b = gets.chomp.split(" ").map(&:to_i)
puts [a+b, a-b, a*b].max


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


a,b = gets.split.map(&:to_i)
puts [a+b,a-b,a*b].max


a,b = gest.strip.split.map(&:to_i)
puts [a*b,a+b,a-b].max


a, b = gets.split.map &:to_i
p [a+b.a-b,a*b].max


a, b = gets.split.map :to_i
p [a+b.a-b,a*b].max


#[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,
        }
    }
}


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);
}


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)));
}


#![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);
}


#![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);
}


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);
}


let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(max(i[0]+i[1],i[0]-i[1],i[0]*i[1]))


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)


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)


//
//  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))


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)


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();


'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'))


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()));


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()));


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'));


k,x=map(int,input().split())
if 500*k>=x:
    print('Yes')
else:
    print('No')


K,X= map(int,input().split())

print("Yes" if K*500 >= X else "No")


a, b = map(int, input().split())
print('Yes' if a*500 >= b else 'No')


s,t=input().split()
print (t+s)


K,X= map(int,input().split())

if 500*K >= X:
  print("Yes")
 else:
  print("No")


K,X= map(int,input().split())

if 500*X >= X:
  print("Yes")
 else:
  print("No")


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();
	}

}


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");
		}
	}
}


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");
		}
	}
}


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);

  }
}


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);

  }
}


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);

  }
}


// 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;
}


#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;
}


#include<stdio.h>
int main()
{
int a,b;

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

return 0;
}


#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";
    }
}


#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;
	}
	}


#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;
}


#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;
}


#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;
}


#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;
}


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

	return 0;
}


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

	return 0;
}


#include <stdio.h>

int main(){
    int k,x;
    scanf("%d %d",&k,&x);
    k*500>= 0 ? printf("Yes\n") : printf("No\n");
    return 0;
}


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"));


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"));


'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"));


((stdin) => {
	const [k, x] = stdin.split(" ");
	if (500 * +k > +x) {
		console.log('Yes');
	}
	else {
		console.log('No');
	}
})(require('fs').readFileSync('/dev/stdin', 'UTF-8'))


((stdin) => {
	const [k, x] = stdin.split(" ");
	if (500 * k > x) {
		console.log('Yes');
	}
	else {
		console.log('No');
	}
})(require('fs').readFileSync('/dev/stdin', 'UTF-8'))


((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'));


// +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
}


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")
	}

}


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")
	}
}


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")
	}
}


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")
	}
}


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
}


# 入力
k,x = gets.chomp.split.map(&:to_i)

# こたえ
if 500 * k >= x
  puts "Yes"
else
  puts "No"
end


k,x = gets.split().map(&:to_i)
if k * 500 >= x
  puts "Yes"
else
  puts "No"
end


K,X=gets.split.map(&:to_i)
puts (500*K>=X ? "Yes":"No")


k,x=gets.split.map &:to_i
p k*500<x ? :No : :Yes


K=gets.to_i
X=gets.to_i

if X<=500*K
  puts "Yes"
else
  puts "No"
end


K = gets.to_i
X = gets.to_i

if X <= 500*K
  puts "Yes"
else
  puts "No"
end


// https://atcoder.jp/contests/abc150/tasks/abc150_a
//
#![allow(unused_imports)]
use std::io::*;
use std::io::Write;
use std::fmt::*;
use std::str::*;
use std::cmp::*;
use std::collections::*;

// Input macros.
// Original by tanakh: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };

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

#[allow(unused_macros)]
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, [ next / $t:tt ]) => {
        {
            let len = read_value!($iter, usize);
            (0..len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
        }
    };

    ($iter:expr, switch) => {
        {
            let ty = read_value!($iter, i32);
            if ty == 1 {
                vec![ty, read_value!($iter, i32), read_value!($iter, i32)]
            } else if ty == 2 {
                vec![ty, read_value!($iter, i32)]
            } else {
                vec![ty, read_value!($iter, i32)]
            }
        }
    };

    ($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")
    };
}

#[allow(unused_macros)]
macro_rules! read_line {
    ($t:tt) => {
        {
            let mut s = String::new();
            std::io::stdin().read_line(&mut s).unwrap();
            s.trim_right().parse::<$t>().unwrap()
        }
    }
}

#[allow(unused_macros)]
macro_rules! dvec {
    ($t:expr ; $len:expr) => {
        vec![$t; $len]
    };

    ($t:expr ; $len:expr, $($rest:expr),*) => {
        vec![dvec!($t; $($rest),*); $len]
    };
}

#[allow(unused_macros)]
macro_rules! ifv {
    ($t:expr, $a:expr, $b: expr) => {
        if $t { $a } else { $b }
    }
}

#[allow(unused_macros)]
macro_rules! fill {
    ($t:expr, $v:expr) => {
        for i in 0..$t.len() {
            $t[i] = $v;
        }
    };
}

#[allow(unused_macros)]
macro_rules! join {
    ($t:expr, $glue:expr) => {
        $t.into_iter().map(|w| w.to_string()).collect::<Vec<_>>().join($glue)
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

// ===

fn main() {
    input! {
        k: i32, x: i32
    };
    println!("{}", ifv!(500*k >= x, "Yes", "No"));
}


/* {{{ */
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: */


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");
	}
}


use proconio::input;

fn main() {
  input! {
    K: i32,
    X: i32,
  }
  println!(if 500 * K >= X { "Yes" } else { "No" });
}


use proconio::input;

fn main() {
  input! {
    K: i32,
    X: i32,
  }
  println!("{}", if 100 * K >= X { "Yes" } else { "No" });
}


use proconio::input;

fn main() {
  input! {
    K: i32,
    X: i32,
  }
  println!(if 100 * K >= X { "Yes" } else { "No" });
}


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")
}


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")}


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")
}


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")
}


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")
}


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")
}


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');
}


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")));


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()


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()


# -*- 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")


def main():
    X, A, B = map(int, input().split())

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

main()


x,a,b = map(int,input().split())
print("A" if abs(x-a)<abs(x-b) else "B")


a,b,c = map(int,input().split())

if abs(a-b) > abs(a-c):
    print('A')
else:
    print('B')


x , a , b = map(int,input().split())
if abs(x-a) > abs(x-b):
    print("A")
else:
    print("B")


x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
  print(a)
else:
  print(b)


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");
	}
}


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();
	}
}


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();
	}
}


import java.util.*; import java.io.*; import java.math.*;
public class Main{
	//Don't have to see. start------------------------------------------
	static class InputIterator{
		ArrayList<String> inputLine = new ArrayList<String>(1024);
		int index = 0; int max; String read;
		InputIterator(){
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			try{
				while((read = br.readLine()) != null){
					inputLine.add(read);
				}
			}catch(IOException e){}
			max = inputLine.size();
		}
		boolean hasNext(){return (index < max);}
		String next(){
			if(hasNext()){
				return inputLine.get(index++);
			}else{
				throw new IndexOutOfBoundsException("There is no more input");
			}
		}
	}
	static HashMap<Integer, String> CONVSTR = new HashMap<Integer, String>();
	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
	static PrintWriter out = new PrintWriter(System.out);
	static void flush(){out.flush();}
	static void myout(Object t){out.println(t);}
	static void myerr(Object t){System.err.print("debug:");System.err.println(t);}
	static String next(){return ii.next();}
	static boolean hasNext(){return ii.hasNext();}
	static int nextInt(){return Integer.parseInt(next());}
	static long nextLong(){return Long.parseLong(next());}
	static double nextDouble(){return Double.parseDouble(next());}
	static ArrayList<String> nextStrArray(){return myconv(next(), 8);}
	static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
	static ArrayList<Integer> nextIntArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Integer> ret = new ArrayList<Integer>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Integer.parseInt(input.get(i)));
		}
		return ret;
	}
	static ArrayList<Long> nextLongArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Long> ret = new ArrayList<Long>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Long.parseLong(input.get(i)));
		}
		return ret;
	}
	static String myconv(Object list, int no){//only join
		String joinString = CONVSTR.get(no);
		if(list instanceof String[]){
			return String.join(joinString, (String[])list);
		}else if(list instanceof ArrayList){
			return String.join(joinString, (ArrayList)list);
		}else{
			throw new ClassCastException("Don't join");
		}
	}
	static ArrayList<String> myconv(String str, int no){//only split
		String splitString = CONVSTR.get(no);
		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
	}
	public static void main(String[] args){
		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
		solve();flush();
	}
	//Don't have to see. end------------------------------------------
	static void solve(){//Here is the main function
      ArrayList<Integer> one = nextIntArray();
      int X = one.get(0);
      int A = Math.abs(one.get(0) - one.get(1));
      int B = Math.abs(one.get(0) - one.get(2));
      if(A < B){
        myout("B");
      }else{
        myout("A");
      }

	}
	//Method addition frame start

	//Method addition frame end
}


import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int x=scan.nextInt(),a=scan.nextInt(),b=scan.nextInt();
		if(Math.min(a, b)<=x) {
			System.out.println("B");
		}
		else if(Math.min(a, b)>=x) {
			System.out.println("A");
		}

	}

}


import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int x=scan.nextInt(),a=scan.nextInt(),b=scan.nextInt();
		if(Math.min(a, b)<=x) {
			System.out.println("B");
		}
		else {
			System.out.println("A");
		}

	}

}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>

using namespace std;

int main(){
	int x,a,b;
	scanf("%d %d %d",&x,&a,&b);

	if(abs(x-a)<abs(x-b)){
		printf("A\n");
	}else{
		printf("B\n");
	}

	return 0;
}


#include<cmath>
#include <stdio.h>
using namespace std;
int main()
{
int n,a,b;
scanf("%d%d%d",&n,&a,&b);
if (abs(n-a)<abs(n-b))
printf("A");
else
printf("B");
}


#include <cstdio>
#include <complex>

int main() {
    int x, a, b;
    scanf("%d %d %d", &x, &a, &b);
    if (std::abs(a - x) > std::abs(b - x))
        puts("B");
    else
        puts("A");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int x,a,b;
  cin>>x>>a>>b;
  if(x-a>x-b) cout<<"B"<<endl;
  else cout<<"A"<<endl;

  return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main(){
	int x, a, b;
	cin >> x >> a >> b;
	int saa = x-a;
	int sab = x-b;
	if(saa<0) saa=-saa;
	if(sab<0) sab=-sab;
	if(saa>sab) cout << 'A' << endl;
	if(saa<sab) cout << 'B' << endl;
}


#include <iostream>
using namespace std;

int main(){
  int x , a , b;
  cin >> x >> a >>b;
  if((x-a) < (x-b)) cout << "A" << endl;
  else cout << "B" << endl;
  return 0;
}


#include<stdio.h>

int main()
{
	int x, a, b;
	scanf("%d %d %d", &x, &a, &b);
	if (x > a) {
		a = x - a;
	}
	else {
		a = a - x;
	}
	if (x > b) {
		b = x - b;
	}
	else {
		b = b - x;
	}
	if (a > b) {
		printf("B");
	}
	else {
		printf("A");
	}
	return 0;
}


#include <stdio.h>
#include <stdlib.h>

int main(){
	int a ,b,x;

	scanf("%d%d%d",&x,&a,&b);
	if(abs(x-a)<abs(x-b)) printf("A");
	else printf("B");

	return 0;
}


#include <stdio.h>

int ll(int a){
	if(a<0) a=0-a;
	return a;
}

int main(void){
	int x,a,b;
	scanf("%d %d %d",&x,&a,&b);
	if(ll(a-x)<ll(b-x)){printf("A");}else{printf("B");}

	return 0;
}


#include<stdio.h>
#include<stdlib.h>
int tikai(int a,int b,int c){
  if(abs(b-a)>abs(c-a))
    return 'A';
  else
    return 'B';
}
  int main(){
  int a,b,c;
  scanf("%d%d%d",&a,&b,&c);
  printf("%c",tikai(a,b,c));

  return 0;
}


#include<stdio.h>
#include<stdlib.h>
char tikai(int a,int b,int c){
  char d='A',e='B';
  if(abs(b-a)>abs(c-a))
    return d;
  else
    return e;
}
  int main(){
  int a,b,c;
  scanf("%d%d%d",&a,&b,&c);
  printf("%c",tikai(a,b,c));

  return 0;
}


#include<stdio.h>
char tikai(int a,int b,int c){
  char d='A',e='B';
  if(abs(b-a)>abs(c-a))
    return d;
  else
    return e;
}
  int main(){
  int a,b,c;
  scanf("%d%d%d",&a,&b,&c);
  printf("%c",tikai(a,b,c));

  return 0;
}