jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  // 1行目がinput[0], 2行目がinput[1], …に入る
  input = input.split("\n");

  var S = input[0];
  var N = S.length;
  var c1 = isPalindrome( S );
  var l2 = ( N - 1 ) / 2;
  var S2 = S.substr( 0, l2 );
  var c2 = isPalindrome( S2 );
  var l3 = ( N + 3 ) / 2;
  var S3 = S.substr( l3 - 1 );
  var c3 = isPalindrome( S3 );
  if( c1 * c2 * c3 == 1 ){
    console.log( 'Yes' );
  }else{
    console.log( 'No' );
  }
}

function isPalindrome( s ){
  var l = s.length;
  var n = Math.floor( l / 2 );
  var r = 1;
  for( var i = 0; i < n && r == 1; i ++ ){
    var c1 = s.charAt( i );
    var c2 = s.charAt( l - 1 - i );
    r = ( c1 == c2 ? 1 : 0 );
  }
  
  return r;
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main
 
import (
	"fmt"
	"unicode/utf8"
)
 
func main() {
	var s string
	fmt.Scan(&s)
	l := utf8.RuneCountInString(s)
	s1 := s[0:(l - 1) / 2]
	s2 := s[(l + 2) / 2:l]
	if s == reverse(s) && s1 == reverse(s1) && s2 == reverse(s2) {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}

func reverse(s string) string {
    rs := []rune(s)
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        rs[i], rs[j] = rs[j], rs[i]
    }
    return string(rs)
}
//  [ruby]
s = gets.chomp.split("")
arr1 = []
arr2 = []
first = (s.size - 1) / 2
last = (s.size + 3) / 2
ss = s.reverse
s1 = s.join("")
s2 = ss.join("")
if first % 2 == 1
    (0..first-1).each do |i|
        arr1 << s[i]
    end
    j = 0
    (last-1..s.size-1).each do |i|
        arr2 << s[i]
    end
    arr1m = arr1.join("")
    arr2m = arr2.join("")

    arr1r = arr1.reverse.join("")
    arr2r = arr2.reverse.join("")
    if arr1m == arr1r && arr2m == arr2r &&  s1 == s2
        puts "Yes"
    else
        puts "No"
    end
elsif first % 2 == 0
    (0..first-1).each do |i|
        arr1 << s[i]
    end
    j = 0
    (last-1..s.size-1).each do |i|
        arr2 << s[i]
    end
    arr1m = arr1.join("")
    arr2m = arr2.join("")

    arr1r = arr1.reverse.join("")
    arr2r = arr2.reverse.join("")
    if arr1m == arr1r && arr2m == arr2r  &&  s1 == s2
        puts "Yes"
    else
        puts "No"
    end
end
//  [ruby]
s = gets.chomp
length = s.size
ans = 'No'

def kaibun(word)
    (word.size/2).times do |i|
        if word[i] != word[word.size-1-i]
            return false
        end
    end
    true
end


if kaibun(s) && kaibun(s[0...((s.size-1)/2)]) && kaibun(s[((s.size+2)/2)..-1])
    ans = 'Yes'
end
puts ans
//  [ruby]
S = gets.chomp.split("")
f = S.slice(0, (S.length-1)/2)
b = S.slice((S.length+3)/2-1..-1)
ans = f==b ? "Yes" : "No"
# p S,f,b
puts ans
//  [rust]
fn main() {
    proconio::input! {
        s: proconio::marker::Bytes,
    }
    let n=s.len();
    let f=|j: usize, k: usize| {
        for i in 0..k-j {
            if s[i+j]!=s[k-i-1] {
                return false;
            }
        }
        true
    };
    println!("{}",if f(0,n) && f(0,(n-1)/2) && f((n+3)/2-1,n) {"Yes"} else {"No"});
}
//  [swift]
import Foundation

let line: String = readLine()!
var length = (line.characters.count-1)/2
let a = line.substringToIndex(line.startIndex.advancedBy(length))
var b = line.substringFromIndex(line.endIndex.advancedBy(-length))
if a == b {
    print("Yes")
}else{
    print("No")
}
//  [swift]
import Foundation

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

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

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

let S = readLine()!
let length = S.characters.count
let front = S.endIndex.advancedBy(-length / 2 - 1)
let back = S.startIndex.advancedBy(length / 2 + 1)

if S.substringToIndex(front) == S.substringFromIndex(back) {
  print("Yes")
} else {
  print("No")
}
//  [typescript]
import * as fs from 'fs';
// main
function main(input: string[]) {
    // param
    var s: string = "";
    var ans: string = "";
    // init
    s = input.shift();
    // solve
    function isreverse(s: string) {
        return s.split("").reverse().join("") == s;
    }
    if (isreverse(s) &&
        isreverse(s.substring(0, (s.length - 1) / 2)) &&
        isreverse(s.substring((s.length + 3) / 2 - 1, s.length))) {
        ans = "Yes";
    } else {
        ans = "No";
    }

    // answer
    console.log(ans);
}
// entrypoint
function entrypoint() {
    try {
        // linux
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            main(input);
        });
    }
}
entrypoint();
//  [typescript]
const stdin: string[] = [];

function main() {
    const input = stdin[0];
    const length = input.length;
    const A = input.substring(0, (length - 1) / 2);
    const B = input.substring(((length - 1) / 2) + 1);

    console.log(A === B ? "Yes" : "No");
}

require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
}).on("line", _ => {
    stdin.push(_);
}).on("close", () => main());
//  [typescript]
import { stringify } from "querystring";

process.stdin.resume();
process.stdin.setEncoding('utf8');

// 標準入力取込
var g_input = '';
process.stdin.on('data', function(chunk) {
    g_input += chunk;
});
process.stdin.on('end', function() {
    main(g_input.split(/\r?\n/));
});

// 解答
function main(inputs:Array<string>) : void {

    // 入力した文章
    let sentence: string = inputs[0];
    let isPalindrome: boolean = false;
    let charNum: number = sentence.length;
    
    if (palindromeCheck(sentence)
       && palindromeCheck(sentence.substring(0, (charNum - 1) / 2))
       && palindromeCheck(sentence.substring(Math.round((charNum + 3) / 2) - 1, charNum))) {

        isPalindrome = true;
    }

    if (isPalindrome) {

        console.log('Yes');
    } else {

        console.log('No');
    }
}

function palindromeCheck(sentence: string) : boolean {

    const reversed = sentence.split('')
                             .reverse()
                             .join('');

    if (sentence == reversed) {

        return true;
    }
    
    return false;
}
//  [python]
N = int(input())
A = int(input())
print((N*N)-A)
//  [python]
print(int(input())**2-int(input()))
//  [python]
a = int(input())
b = int(input())
print((a**2-b))
//  [python]
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

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

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


def main():
    n = I()
    a = I()

    return n**2 - a


print(main())
//  [python]
print(eval(input()+'**2-'+input()))
//  [python]
import sys
import math
from fractions import gcd
# import queue
# from collections import Counter
# from itertools import accumulate
# from functools import reduce

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

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

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

big_prime = 1000000007

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

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


N =  int(sys.stdin.readline())
A =  int(sys.stdin.readline())

print(N ** 2 - A)
//  [java]
import java.io.*;
import java.util.*;

public class Main{

	public static void main(String[]arg) throws IOException{
		new Main().read();
	}

	public void read() throws IOException{
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int N,A;
		N = Integer.parseInt(in.readLine());
		A = Integer.parseInt(in.readLine());
		System.out.println(N*N - A);
	}
}
//  [java]
import java.io.*;
import java.util.*;

public class Main {

	final static long MOD = 1000000007;
	public static String[] Ws = null;
	public static int wsIndx = 0;
	public static BufferedReader in = null;
	public static void main(String[] args) throws Exception {
		solution(args);
		if(in!=null){
			in.close();
		}
	}

	public static void solution(String[] args) throws Exception{

		int N = nextInt();
		int A = nextInt();



		System.out.println(N*N-A);

	}
	public static String[] toStringArray(String s) {
		String[] tmp = new String[s.length()];
		char[] c = s.toCharArray();
		for (int i = 0; i < tmp.length; i++) {
			tmp[i] = String.valueOf(c[i]);
		}
		return tmp;
	}

	public static void check() throws Exception{
		if(in == null){
			in = new BufferedReader(new InputStreamReader(System.in));
		}
		if(Ws==null || Ws.length<=wsIndx){
			Ws = in.readLine().split(" ");
			wsIndx=0;
		}
	}
	public static int nextInt()throws Exception{
		check();
		return Integer.parseInt(Ws[wsIndx++]);
	}

	public static long nextLong()throws Exception{
		check();
		return Long.parseLong(Ws[wsIndx++]);
	}

	public static String nextString()throws Exception{
		check();
		return Ws[wsIndx++];
	}

	public static int[] nextInts()throws Exception{
		check();
		int[] tmp = new int[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Integer.parseInt(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static long[] nextLongs()throws Exception{
		check();
		long[] tmp = new long[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Long.parseLong(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static String[] nextStrings()throws Exception{
		check();
		wsIndx=Ws.length;
		return Ws;
	}


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

public class Main {

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

  	int N = in.nextInt();
  	int A = in.nextInt();
  	N = N * N;

  	System.out.println(N - A);
  }


}
//  [java]

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int A = sc.nextInt();
		System.out.println(N * N - A);
	}
}
//  [cpp]
#include <stdio.h>

int main()
{
int N,M;
scanf("%d %d",&N,&M);
printf("%lld",(long long)N*N-M);
return 0;
}
//  [cpp]
#include<cstdio>
int main()
{
	int n,a;
	scanf("%d%d",&n,&a);
	printf("%d",(n*n)-a);
	return 0;
}
//  [cpp]
#include <cstdio>

int main()
{
    int N, A;
    scanf("%d %d", &N, &A);
    printf("%d", N*N-A);
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

#define endl '\n'

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    int n, a;
    cin >> n >> a;
    int res = n * n - a;
    if(res <= 0)
        cout << 0;
    else
        cout << res;

    return 0;
}
//  [cpp]
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include <vector>
#include <map>
using namespace std;
long long Read() {
	long long x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {
		if(c=='-')f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();
	return x*f;
}
int main() {
	long long n,b;
	 n=Read(),b=Read();
	 cout<<n*n-b; 
	return 0;
}
//  [cpp]
#include <iostream>
using namespace std;

int main()
{
    int N, A;
    cin	>> N >>	A;

    cout << N*N-A << endl;

    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int N,A;
    int ans;
  
    // 整数の入力
    scanf("%d", &N);
    scanf("%d", &A);
  
    // 黒色の数の計算
    ans = (N*N) - A ;   
    //
  
    // 出力
    printf("%d\n", ans);
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

	int num, a;

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

	printf("%d", num * num - a);

	return 0;

}
//  [c]
#include<stdio.h>
int main(){
  int N,A;
  scanf("%d",&N);
  scanf("%d",&A);

  printf("%d",N*N-A);
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int main(void){
  int N, A;
  scanf("%d",&N);
  scanf("%d",&A);
  printf("%d",N*N-A);
  return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

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

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

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

    printf("%d", n*n-a);
    
    return 0;
}
//  [c]
#include <stdio.h>

int main(){

    int n, a, g, c;

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

    g = n*n;
    c = g-a;

    printf("%d", c);

return 0;
}
//  [javascript]
function Main(input) {
input = input.split("\n");
var a = parseInt(input[0], 10);
var b = parseInt(input[1], 10);
var s = Math.pow(a, 2) - b;
  console.log('%s', s);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const numbers = input.split('\n').map(n => Number(n));
  const n = numbers[0];
  const a = numbers[1];

  console.log(n * n - a);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split("\n").map(Number);
console.log(input[0]*input[0]-input[1])
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	var N = parseInt(input[0],10);
	var A = parseInt(input[1],10);

	var ans = N * N - A;

	console.log('%d',ans);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

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

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

function Main(input) {
    var n = parseInt(input[0], 10);
    var a = parseInt(input[1], 10);

    var black = n * n - a;
    console.log(black);

    return 0;
}
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split("\n").map(Number);
  console.log(a[0]*a[0]-a[1]);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

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

import (
	"fmt"
)

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

import (
	"fmt"
)

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

	fmt.Println(n*n - a)
}
//  [go]
package main

// Solution for https://atcoder.jp/contests/abc074/tasks/abc074_a

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

type contest struct {
	in  io.Reader
	out io.Writer
}

func (con *contest) Scan(a ...interface{}) (int, error) {
	return fmt.Fscan(con.in, a...)
}
func (con *contest) Scanln(a ...interface{}) (int, error) {
	return fmt.Fscanln(con.in, a...)
}
func (con *contest) Scanf(f string, a ...interface{}) (int, error) {
	return fmt.Fscanf(con.in, f, a...)
}
func (con *contest) Print(a ...interface{}) (int, error) {
	return fmt.Fprint(con.out, a...)
}
func (con *contest) Println(a ...interface{}) (int, error) {
	return fmt.Fprintln(con.out, a...)
}
func (con *contest) Printf(f string, a ...interface{}) (int, error) {
	return fmt.Fprintf(con.out, f, a...)
}
func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	con := &contest{in: in, out: out}
	con.main()
}

func (con *contest) main() error {
	var n, a int
	con.Scan(&n, &a)
	con.Println(n*n - a)
	return nil
}
//  [go]
package main

import (
	"fmt"
)

func main() {
  var n, a int
  fmt.Scanf("%d", &n)
  fmt.Scanf("%d", &a)
  
  ans := n * n - a
  
  fmt.Printf("%d\n", ans)
}
//  [ruby]
n = gets.to_i
a = gets.to_i
 
puts n * n - a
//  [ruby]
n,a=$<.map(&:to_i)
p n*n-a
//  [ruby]
N = gets.to_i
A = gets.to_i
puts N**2-A
//  [ruby]
n = gets.to_i
a = gets.to_i
puts n*n-a
//  [ruby]
n = gets.to_i
a = gets.to_i
puts n*n - a
//  [ruby]
p gets.to_i**2-gets.to_i
//  [rust]
fn main(){
    let n: u32 = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().parse().unwrap()
    };
    let a: u32 = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().parse().unwrap()
    };
    println!("{}\n", n*n - a);
}
//  [rust]
fn main() {
    let n: u32 = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().parse().unwrap()
    };
    let a:u32 = {
        let mut t = String::new();
        std::io::stdin().read_line(&mut t).unwrap();
        t.trim_right().parse().unwrap()
    };
    print!("{}\n", n * n - a);
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn main() {
    let n: usize = read();
    let a: usize = read();
    println!("{}", n * n - a);
}
//  [rust]
#![allow(unused_imports)]
// use itertools::Itertools;
use proconio::{input, marker::*};

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

fn main() {
    let n = get!(i32);
    let a = get!(i32);
    println!("{}", n.pow(2) - a);
}
//  [rust]
use text_io::*;
use std::collections::HashMap;
use std::process::exit;

fn main() {
    let t:usize = read!();
    let a:usize = read!();
    println!("{}",t*t-a)
}
//  [swift]
import Glibc
extension String: CollectionType {}

//var xt = readLine()!.split(" ").map { Int($0)! }
var n = Int(readLine()!)!
var a = Int(readLine()!)!
print(n*n-a)
//  [swift]
let N=Int(readLine()!)!;print(N*N-Int(readLine()!)!)
//  [swift]
let x = Int(readLine()!)
let y = Int(readLine()!)
print(x!*x!-y!)
//  [typescript]
declare function require(x: string): any;

var input = require("fs").readFileSync("/dev/stdin", "utf8");
input = input.split("\n");

//const na = input.shift().split(" ");
const n = +input[0];
const a = +input[1];

console.log(n*n-a);
//  [typescript]
"use strict";

const App  = (arg:any) => {
  const value = arg.trim().split("\n");
  const N:number = parseInt(value[0].split(" ")[0], 10);
  const A:number = parseInt(value[1].split(" ")[0], 10);

  const SquaredN = N * N;
  const result = SquaredN - A;
  console.log(result);
}

App(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

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

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

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

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

  return N * N - A;
};

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

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

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

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

        public main(this: TaskA): void {
            const n:number = +this.args[0][0];
            const a:number = +this.args[1][0];
            console.log(Math.pow(n,2) - a);
        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
    const task: AtCoder.Task = new TaskA(args);
    task.main();
}
//  [typescript]
const t={input:require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/),n:(arg:number=0):any=>{if(arg){const a:number[]=[];for(let i=0;i<arg;i++) {a.push(t.n());}return a;}else{const a = t.input[0];t.input.shift();return Number(a);}},s:(arg:number=0):any=>{if(arg){const a:string[]=[];for(let i=0;i<arg;i++){a.push(t.s());}return a;}else{const a=t.input[0];t.input.shift();return String(a);}},c:(arg:number=0):any=>{if(arg) {const a:string[]=[];for(let i=0;i<arg;i++) {a.push(t.c());}return a;}else{let a=t.input[0].split('');const b=a[0];a.shift();if(a.length>0){t.input[0]=a.join('');}else{t.input.shift();}return String(b);}},o: (...arg)=>{console.log(...arg);},abs:(a)=>{return Math.abs(a);},min:(...a)=>{return Math.min(...a);},max:(...a)=>{return Math.max(...a);},floor:(a)=>{return Math.floor(a);},asc:(ar:number[])=>{return ar.sort((a,b)=>{return a-b});},desc:(ar:number[])=>{ return ar.sort((a,b)=>{return b-a});},sw:(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length;i+=2){if(eval(a+op+arr[i]))return arr[i+1]}return arr[arr.length-1];}}
const main = ()=>{
  let [a,b] = t.n(2)
  t.o(a*a-b)
}
main()
//  [python]
import numpy as np
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
k = int(input())

flg = True
if np.abs(a-b) > k:
    flg = False
if np.abs(a-c) > k:
    flg = False
if np.abs(a-d) > k:
    flg = False
if np.abs(a-e) > k:
    flg = False
if np.abs(b-c) > k:
    flg = False
if np.abs(b-d) > k:
    flg = False
if np.abs(b-e) > k:
    flg = False
if np.abs(c-d) > k:
    flg = False
if np.abs(c-e) > k:
    flg = False
if np.abs(d-e) > k:
    flg = False
    
if flg:
    print('Yay!')
else:
    print(":(")
//  [python]
a = [int(input()) for _ in range(6)]

if a[-2] - a[0] > a[-1]:
    print(":(")
else:
    print("Yay!")
//  [python]
# encoding:utf-8
import copy
import numpy as np
import random
import bisect #bisect_left　これで二部探索の大小検索が行える

length = []

for i in range(5):
    length.append(int(input()))

k = int(input())

length.sort()
if length[-1]-length[0] > k:
    print(":(")
else:
    print("Yay!")
//  [java]
import java.io.*;
import java.util.Arrays;

public class Main {
    private static int[] pos = new int[5];
    private static int k;

    private static String solver() {
        int min = Arrays.stream(pos).min().getAsInt();
        int max = Arrays.stream(pos).max().getAsInt();
        if(k >= max - min){
            return "Yay!";
        }else{
            return ":(";
        }

    }


    public static void main(String[] args) {

        InputStreamReader is = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(is);

        try {
            for(int i=0; i<5; i++) {
                String[] inputArray = br.readLine().split(" ");
                pos[i] = Integer.parseInt(inputArray[0]);
            }
            String[] inputArray = br.readLine().split(" ");
            k = Integer.parseInt(inputArray[0]);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(solver());

    }
}
//  [java]
import java.util.*;
import java.util.stream.*;
import java.util.function.*;

public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println(new Main().solve());
    }
    
    // パラメタ渡しもちゃんとクラス作るのも面倒なので手抜き
    // 必要な値はここで全部取ってしまう
    Scanner sc = new Scanner(System.in);
    // int n = Integer.parseInt(sc.next());
    // {sc.nextLine();}
    int[] a = IntStream.range(0, 5).map(i -> Integer.parseInt(sc.next())).toArray();
    int k =  Integer.parseInt(sc.next());
    String solve() {
        for(int i : a) {
            for(int j : a) {
                if(i - j > k) {
                    return ":(";
                }
            }
        }
        return "Yay!";
    }
    
}
// public class Main {
//     public static void main(String[] args) throws Exception {
//         Scanner sc = new Scanner(System.in);
//         int a = sc.nextInt();
//         int b = sc.nextInt();
//         int c = sc.nextInt();
//         int d = sc.nextInt();
//         int e = sc.nextInt();
        
//         IntStream.of(a, b, c, d, e).
//         int k = sc.nextInt();
//         System.out.println();
//     }
    
//     // // パラメタ渡しもちゃんとクラス作るのも面倒なので手抜き
//     // // 必要な値はここで全部取ってしまう
//     // Scanner sc = new Scanner(System.in);
//     // int n = Integer.parseInt(sc.next());
//     // {sc.nextLine();}
//     // int[] a = IntStream.range(0, n).map(i -> Integer.parseInt(sc.next())).toArray();
    
//     // String solve() {
//     //     return n + "" + Arrays.toString(a);
//     // }
    
// }
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1000000007;

int main(){
    ll a,b,c,d,e,k;
    cin >> a >> b >> c >> d >> e >> k;
    if(e - a <= k)
        cout << "Yay!" << "\n";
    else
        cout << ":(" << "\n";
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

#define REP(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define REPS(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define RREP(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define RREPS(i, n) for (int i = ((int)(n)); i > 0; i--)
#define IREP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define IREPS(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RVISORT(v) sort(v.begin(), v.end(), greater<int>());
#define ALL(v) v.begin(), v.end()
#define MP(n, m) make_pair(n, m);
#define COUT(d) cout<<std::setprecision(10)<<d<<endl;
#define CIN(n) getline(cin,n);

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using ll = long long;
using ul = unsigned long;

typedef long long ll;

template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }

const int mod=1e9+7;

struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};

mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}

bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;

    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }

    return true;
}

map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}

void printv(VI& v){
  REP(i,v.size()) cout << v[i] << " ";
  cout << endl;
}

int vtotal(VI& v){
  int total=0;
  REP(i,v.size()) total+=v[i];
  return total;
}

int main()
{
  cin.tie( 0 );
  ios::sync_with_stdio( false );
	
  //init(); // mint初期化
  int a,b,c,d,e,k;
  cin>>a>>b>>c>>d>>e>>k;
  string ans="Yay!";
  if(e-a>k)ans=":(";
  cout<<ans<<endl;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  vector<int>vec(5);
  cin >> vec[0] >> vec[1] >> vec[2] >> vec[3] >> vec[4];
  int k;
  cin >> k;
  bool x = true;
  for(int i=0; i<4; i++){
    for(int j=i+1; j<5; j++){
      if(vec[j]-vec[i] > k){
        cout << ":(" << endl;
        return 0;
      }
    }
  }
  cout << "Yay!" << endl;
}
//  [c]
#include <stdio.h>
//#include <string.h>

int main(void){
  
  int a,b,c,d,e,k = 0; 
  scanf("%d", &a);
  scanf("%d", &b);
  scanf("%d", &c);
  scanf("%d", &d);
  scanf("%d", &e);
  scanf("%d", &k);
  
  if(k<e-a) printf(":(");
  else printf("Yay!");


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

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

typedef long long ll;
typedef int keytype;

int gcd(int a, int b){ return (a % b) ? gcd(b, a % b) : b;}
int lcm(int a, int b){ return (a / gcd(a, b)) * b;}

/* a[0], ..., a[n-1] の数の最大公約数 */
int ngcd(int n, int a[])
{
    int i, d;

    d = a[0];
    for (i = 1; i < n && d != 1; i++)
        d = gcd(a[i], d);
    return d;
}

void quicksort(keytype a[], int first, int last)
{
    int i, j;
    keytype x, t;

    x = a[(first + last) / 2];
    i = first;  j = last;
    for ( ; ; ) {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i >= j) break;
        t = a[i];  a[i] = a[j];  a[j] = t;
        i++;  j--;
    }
    if (first  < i - 1) quicksort(a, first , i - 1);
    if (j + 1 < last) quicksort(a, j + 1, last);
}

int is_prime(int x){
    if(x <= 1) return 0;
    for(int i = 2; i * i <= x; i++){
        if(x % i == 0) return 0;
    }
    return 1;
}

int is_substr(char s[], char t[], int i){
    int flag = 1;

    if(s[i] == '\0') flag = 0;

    for(int j = 0; j < strlen(t); ++j, ++i){
        if(s[i] != t[j]){
            flag = 0;
            break;
        }
    }
    return flag;
}

// factor list, number of factors, natural number
void factorize(int ftr[], int *num, int n){
    int a = 2, cnt = 0;

    while(n >= a){
        if(n % a == 0){
            n = n / a;
            ftr[cnt++] = a;
        }else{
            a++;
        }
    }
    *num = cnt;
}

//#define N 5
//int p[N + 1];
int nextperm(int p[], int N)  /* 辞書式順序で次の順列 */
{
    int i, j, t;

    i = N - 1;
    p[0] = 0;  /* 番人 */
    while (p[i] >= p[i + 1]) i--;
    if (i == 0) return 0;  /* 完了 */
    j = N;
    while (p[i] >= p[j]) j--;
    t = p[i];  p[i] = p[j];  p[j] = t;
    i++;  j = N;
    while (i < j) {
        t = p[i];  p[i] = p[j];  p[j] = t;  i++;  j--;
    }
    return 1;  /* 未了 */
}

void comb(int size1, int size2, int v[size1][size2]){
  for(int i = 0; i < size1; i++){
    v[i][0] = 1;
    v[i][i] = 1;
  }
  for(int k = 1; k < size1; k++){
    for(int j = 1; j < k; j++){
      v[k][j] = (v[k-1][j-1] + v[k-1][j]);
    }
  }
}

int abs_val(int a, int b){
    if(a > b) return a - b;
    else return b - a;
}

const int inf = 1012345678;
int main(){
    int p[5];
    int index[6] = {0, 1, 2, 3, 4, 5};
    int k;

    scanf("%d %d %d %d %d %d", &p[0], &p[1], &p[2], &p[3], &p[4], &k);

    for(int i = 0; i < 5; ++i){
        for(int j = i + 1; j < 5; ++j){
            if((p[j] - p[i]) > k){
                puts(":(");
                return 0;
            }
        }
    }

    puts("Yay!");

    return 0;
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
  input = input.split("\n")
  // tmp0 = input[0].split(" ")
  // N = Number(tmp0[0])
  // M = Number(tmp0[1])
  a = Number(input[0])
  b = Number(input[1])
  c = Number(input[2])
  d = Number(input[3])
  e = Number(input[4])
  k = Number(input[5])

  if(((b-a) > k) || ((c-a) > k) || ((d-a) > k) || ((e-a) > k)
  || ((c-b) > k) || ((d-b) > k) || ((e-b) > k)
  || ((d-c) > k) || ((e-c) > k)
  || ((e-d) > k))
  {
    console.log(":(")
  }else{
    console.log("Yay!")
  }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
// Main("4 30\n6 18\n2 5\n3 10\n7 9\n")
//  [javascript]
function Main(input) {
    // 1行目がinput[0], 2行目がinput[1], …に入る
    tmp = input.split("\n");
    tmp = tmp.map(Number);
    k = tmp[5];
    a = new Array;
    for(i = 0; i < 5; i++){
        for(j=0;j< 5;j++ ){
            a[5*i+j] = Math.abs(tmp[i]-tmp[j])
            }
        }
    if(Math.max.apply(null, a) > k){
        console.log(":(");
    }else{
        console.log("Yay!");
    }

    
    
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

var rdr = bufio.NewReaderSize(os.Stdin, 1000000)

func readLine() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func main() {
	var input []int
	for i := 0; i < 6; i++ {
		in, _ := strconv.Atoi(readLine())
		input = append(input, in)
	}
	for i := 0; i < 5; i++ {
		for j := i; j < 5; j++ {
			if input[j]-input[i] > input[5] {
				fmt.Println(":(")
				return
			}
		}
	}
	fmt.Println("Yay!")
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - Five Antennas
	A := make([]int, 6)
	for i := 0; i < 6; i++ {
		fmt.Scanf("%d", &A[i])
	}

	if A[4]-A[0] > A[5] {
		fmt.Println(":(")
	} else {
		fmt.Println("Yay!")
	}
}
//  [go]
package main

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

func main() {
	v := ReadInts(5)
	k := ReadInt()

	ok := true
	for i := 0; i < 5; i++ {
		for j := 0; j < 5; j++ {
			if Abs(v[i]-v[j]) > k {
				ok = false
				break
			}
		}
	}
	if ok {
		fmt.Println("Yay!")
	} else {
		fmt.Println(":(")
	}
}

func Abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

var reader = bufio.NewReader(os.Stdin)

func Scan(a ...interface{}) {
	if _, err := fmt.Fscan(reader, a...); err != nil {
		panic(err)
	}
}
func ReadInt() (i int)       { Scan(&i); return }
func ReadString() (s string) { Scan(&s); return }
func ReadInts(n int) []int {
	v := make([]int, n)
	for i := 0; i < n; i++ {
		Scan(&v[i])
	}
	return v
}
//  [ruby]
*a,b=`dd`.split.map(&:to_i)
puts a.max-a.min>b ?':(':'Yay!'
//  [ruby]
x = `dd`.split.map &:to_i
puts (x[4] - x[0]).abs > x[5] ? ":(": :Yay!
//  [ruby]
a = Array.new(5) { gets.to_i }
k = gets.to_i
ans = true
a.each_with_index { |x, i|
  a.each_with_index{ |y, j|
    next if i >= j
    if y - x > k
      ans = false
      break
    end
  }
  break unless ans
}

puts (ans ? "Yay!" : ":(")
//  [swift]
import Foundation

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

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



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

var input: [Int] = []
for _ in 0..<5 {
    input.append(readInt()!)
}
print(input[4]-input[0] > readInt()! ? ":(" : "Yay!")
//  [swift]
var a=[Int]();(0..<6).forEach{_ in a+=[Int(readLine()!)!]};print(a[4]-a[0]>a[5] ?":(":"Yay!")
//  [typescript]
namespace Coder {
  class Scanner {
    private buffer: string = '';
    private stdinQueue: any = [];

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

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

  const checkFlag = (f: any) => {
    return f['A'] && f['B'] && f['C'];
  };

  async function slove() {
    const sc = new Scanner();
    const input = [];
    let ans = 'Yay!';
    for (let i = 0; i < 6; i += 1) {
      input.push(+(await sc.getLine()));
    }
    for (let i = 0; i < 5; i += 1) {
      for (let j = i + 1; j < 5; j += 1) {
        const d = Math.abs(input[i] - input[j]);
        if (d > input[5]) {
          ans = ':(';
          break;
        }
      }
    }
    console.log(ans);
    sc.close();
  }

  slove();
}
//  [typescript]
function main(input) {
  const [a, b, c, d, e, k] = input.trim().split("\n").map(n => Number(n));
  let result = "Yay!";
  if (k < e-a) {
    result = ":(";
  }
  console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const input = require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);
const nin=()=>{const r = input[0];input.shift();return Number(r)};
const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};
const sin=()=>{const r = input[0];input.shift();return String(r)}
const out=(...a)=>{console.log(...a)}
const floor=(a)=>{return Math.floor(a)}
const abs=(a)=>{return Math.abs(a)}
const min=(...a)=>{return Math.min(...a)}
const max=(...a)=>{return Math.max(...a)}
const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}}
const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};
const permutation = ({ result = [], pre = [], post, n = post.length }) => {
  if (n > 0) {
    post.forEach((_, i) => {
      const rest = [...post];
      const elem = rest.splice(i, 1);
      permutation({ result, pre: [...pre, ...elem], post: rest, n: n - 1});
    });
  } else {
    result.push(pre);
  }
  return result;
}
const main = ()=>{
  let t = -1;
  let ans = 'Yay!';
  permutation({post:nrin(5), n:2}).some(a=>{
    if(t == -1) t=nin();
    if(abs(a[0] - a[1]) > t){ans = ':('; return true;}
  });
  out(ans);
}
main();
//  [python]
import time
 
time.sleep(0.5)
a, b = map(int, input().split())
print(max(a + b, a - b, a * b))
//  [python]
from subprocess import*
with open('A.py','w')as f:
    f.write('a,b=map(int,input().split())\n')
    for i in range(-100,101):
        f.write('if a==%d:\n'%i)
        for j in range(-100,101):
            f.write('    if b==%d:print(%d)\n'%(j,max(i+j,i-j,i*j)))
call(('python3','A.py'))
//  [python]
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

A, B = rl()

ans = max(A+B, A-B, A*B)
print(ans)
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.stream.Stream;
import java.util.Collection;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.ArrayList;

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

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int A = in.nextInt();
            int B = in.nextInt();

            int plusResult = A + B;
            int minusResult = A - B;
            int timesResult = A * B;

            List<Integer> resultList = new ArrayList<>();
            resultList.add(plusResult);
            resultList.add(minusResult);
            resultList.add(timesResult);

            List<Integer> sortResultList = resultList.stream().sorted().collect(Collectors.toList());
            out.println(sortResultList.get(sortResultList.size() - 1));
        }

    }
}
//  [java]
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.Scanner;
import java.util.stream.Stream;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] in = Stream.of(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

		List<Integer> list = Arrays.asList(in[0] + in[1], in[0] - in[1], in[0] * in[1]);
		Optional<Integer> ans = list.stream().max(Comparator.naturalOrder());
		
		System.out.println(ans.get());
	}
}
//  [java]
import java.util.Comparator;
import java.util.Scanner;
import java.util.stream.Stream;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = Integer.parseInt(sc.next());
		int b = Integer.parseInt(sc.next());
		int ans1 = a + b;
		int ans2 = a - b;
		int ans3 = a * b;
		System.out.println(Stream.of(ans1, ans2, ans3).max(Comparator.naturalOrder()).get());

	}

}
//  [c]
#include<stdio.h>
int main()
{
    int A,B,x,y,z;
    scanf("%d %d",&A,&B);
    x=(A+B);
    y=(A-B);
    z=(A*B);
    if (x>=y&&x>=z)
    {
        printf("%d\n",x);
    }
    else if (y>=x&&y>=z)
        {
        printf("%d\n",y);
        }
    else
        {
        printf("%d\n",z);
        }
}
//  [c]
#include <stdio.h>

int main()
{
  int a, b;
  scanf("%d%d", &a, &b);
  int c, d, e;
  c = a + b;
  d = a - b;
  e = a * b;
  int ans = c > d ? c : d;
  ans = ans > e ? ans : e;
  printf("%d\n", ans);
  return 0;
}
//  [c]
#include<stdio.h>
int main(void)
{
    int A,B;
    int S1=0,S2=0,S3=0;
  
    scanf("%d%d",&A,&B);
    S1=A+B;
    S2=A-B;
    S3=A*B;
  if((S1>=S2)&&(S2>S3)) printf("%d\n",S1);
  else if((S1>=S3)&&(S3>S2)) printf("%d\n",S1);
  else if((S2>=S1)&&(S1>S3)) printf("%d\n",S2);
  else if((S2>=S3)&&(S3>S1)) printf("%d\n",S2);
  else if((S3>=S1)&&(S1>S2)) printf("%d\n",S3);
  else if((S3>=S2)&&(S2>S1)) printf("%d\n",S3);
  else printf("%d\n",S1);
  
  return 0;
}
//  [javascript]
module.exports=function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=0)}([function(e,t,r){r(1)(r(2).readFileSync("/dev/stdin","UTF-8"))},function(e,t){e.exports=function(e){var t=e.split(" "),r=Number(t[0]),n=Number(t[1]),o=Math.max(r+n,r-n,r*n)+0;console.log(o)}},function(e,t){e.exports=require("fs")}]);
//  [javascript]
'use strict'
function main(inp) {
  inp = inp.trim().split(' ').map(n => Number(n));
  console.log(Math.max(inp[0] + inp[1], inp[0] - inp[1], inp[0] * inp[1]))
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main
 
import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"math"
)
 
func run() {

	var A int64;
    A = nextInt();
    var B int64;
    B = nextInt();
	solve(A, B);

}

func solve(A int64, B int64){
	Println(math.Max(math.Max(float64(A+B),float64(A-B)),float64(A*B)))
}


// --- template ---
// Thanks https://gist.github.com/halllllll/853ab587fd82ee3ffe6f7fb7fb499695
 
var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)
 
// Caution: You will get unexpected result if a single token is larger than this size.
const BufferSize = 64 * 1024 * 1024
 
func Print(a ...interface{}) (n int, err error) {
	return fmt.Fprint(out, a...)
}
 
func Printf(format string, a ...interface{}) (n int, err error) {
	return fmt.Fprintf(out, format, a...)
}
 
func Println(a ...interface{}) (n int, err error) {
	return fmt.Fprintln(out, a...)
}
 
func next() string {
	sc.Scan()
	return sc.Text()
}
 
func nextInt() int64 {
	a, err := strconv.ParseInt(next(),10, 64)
	if err != nil {
		log.Fatal(err)
	}
	return a
}

func nextFloat() float64 {
	a, err := strconv.ParseFloat(next(), 64)
	if err != nil {
		log.Fatal(err)
	}
	return a
}

 
func main() {
	sc.Buffer(make([]byte, 0, BufferSize), BufferSize)
	sc.Split(bufio.ScanWords)
	run()
	out.Flush()
}