Year 2118. Androids are in mass production for decades now, and they do all the work for humans. But androids have to go to school to be able to solve creative tasks. Just like humans before.

It turns out that high school struggles are not gone. If someone is not like others, he is bullied. Vasya-8800 is an economy-class android which is produced by a little-known company. His design is not perfect, his characteristics also could be better. So he is bullied by other androids.

One of the popular pranks on Vasya is to force him to compare $x^y$ with $y^x$. Other androids can do it in milliseconds while Vasya's memory is too small to store such big numbers.

Please help Vasya! Write a fast program to compare $x^y$ with $y^x$ for Vasya, maybe then other androids will respect him.


-----Input-----

On the only line of input there are two integers $x$ and $y$ ($1 \le x, y \le 10^{9}$).


-----Output-----

If $x^y < y^x$, then print '<' (without quotes). If $x^y > y^x$, then print '>' (without quotes). If $x^y = y^x$, then print '=' (without quotes).


-----Examples-----
Input
5 8

Output
>

Input
10 3

Output
<

Input
6 6

Output
=



-----Note-----

In the first example $5^8 = 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 = 390625$, and $8^5 = 8 \cdot 8 \cdot 8 \cdot 8 \cdot 8 = 32768$. So you should print '>'.

In the second example $10^3 = 1000 < 3^{10} = 59049$.

In the third example $6^6 = 46656 = 6^6$.

Difficulty: EASY
Tags: Mathematics

Starter code:

Solutions:
from math import log
(x, y) = list(map(int, input().split()))
if x == y:
	print('=')
elif y * log(x) > x * log(y) + 1e-09:
	print('>')
elif y * log(x) + 1e-09 < x * log(y):
	print('<')
else:
	print('=')


import math
str = input()
(x, y) = str.split()
x = int(x)
y = int(y)
lhs = math.log(x) * y
rhs = math.log(y) * x
if lhs == rhs:
	print('=')
elif lhs > rhs:
	print('>')
else:
	print('<')


from math import *

def check(x, y):
	if x == 1 or y == 1:
		if x > y:
			print('>')
		elif x < y:
			print('<')
		else:
			print('=')
		return 0
	a = y / x
	b = log(y) / log(x)
	if a > b:
		print('>')
	elif a < b:
		print('<')
	else:
		print('=')
(x, y) = input().split()
(x, y) = (int(x), int(y))
check(x, y)


def reverse(c):
	return '<' if c == '>' else '>' if c == '<' else '='

def cmp(x, y):
	if x > y:
		return reverse(cmp(y, x))
	return '<' if x == 1 and y > 1 or [x, y] == [2, 3] else '=' if [x, y] == [2, 4] or x == y else '>'
(x, y) = [int(t) for t in input().split()]
print(cmp(x, y))


from math import log
(x, y) = map(int, input().split())
(v1, v2) = (y * log(x), x * log(y))
print(['<', '=', '>'][(v1 > v2) - (v1 < v2) + 1])


import math
(n, m) = map(int, input().split())
x = m * math.log(n)
y = n * math.log(m)
if x > y:
	print('>')
elif x == y:
	print('=')
else:
	print('<')


import math
(x, y) = map(int, input().split())
a = x * math.log(y, 10)
b = y * math.log(x, 10)
if a > b:
	print('<')
elif a < b:
	print('>')
else:
	print('=')


from math import log
(x, y) = [int(x) for x in input().split()]
if y * log(x) == x * log(y):
	print('=')
elif y * log(x) < x * log(y):
	print('<')
else:
	print('>')


from math import *
(x, y) = map(int, input().split())
p = y * log(x)
q = x * log(y)
if p < q:
	print('<')
elif p > q:
	print('>')
else:
	print('=')


import math
(a, b) = map(int, input().split())
c = b * math.log2(a)
d = a * math.log2(b)
if c > d:
	print('>')
elif d > c:
	print('<')
else:
	print('=')


import math
(x, y) = [int(i) for i in input().split(' ')]
lx = y * math.log(x)
ly = x * math.log(y)
if lx < ly:
	print('<')
elif lx > ly:
	print('>')
else:
	print('=')


import math
(x, y) = map(int, input().split())
if y == 0:
	print('>')
elif x % 2 == 0 and y < 0:
	print('<')
elif x % 2 != 0 and y < 0:
	print('>')
elif x > 0 and y > 0:
	h = y * math.log(x)
	g = x * math.log(y)
	if h > g:
		print('>')
	elif h == g:
		print('=')
	else:
		print('<')


import math
(x, y) = list(map(int, input().split()))
xx = y * round(math.log(x), 11)
yy = x * round(math.log(y), 11)
if xx > yy:
	print('>')
elif yy > xx:
	print('<')
else:
	print('=')


import math
(x, y) = [int(i) for i in input().strip().split(' ')]
x = math.log2(x) / x
y = math.log2(y) / y
if x < y:
	print('<')
elif x == y:
	print('=')
else:
	print('>')


import math
(x, y) = tuple(map(int, input().split()))
left = y * math.log(x)
right = x * math.log(y)
if left < right:
	print('<')
elif left > right:
	print('>')
else:
	print('=')


(a, b) = map(int, input().split())
if b == 1 and a > 1:
	print('>')
elif a == 1 and b > 1:
	print('<')
elif a == b:
	print('=')
elif a + b == 6:
	print('=')
elif a == 3:
	print('>')
elif b == 3:
	print('<')
elif a < b:
	print('>')
elif a > b:
	print('<')


import math
(a, b) = map(int, input().split())
l_x = b * math.log(a, 10)
l_y = a * math.log(b, 10)
if abs(l_x - l_y) == 0:
	print('=')
elif l_x > l_y:
	print('>')
else:
	print('<')


import math
(x, y) = map(int, input().split())
t1 = y * math.log10(x)
t2 = x * math.log10(y)
if t1 > t2:
	print('>')
elif t1 < t2:
	print('<')
elif t1 == t2:
	print('=')


import math
(x, y) = map(int, input().split())
res = y * math.log(x) - x * math.log(y)
if res < 0:
	print('<')
elif res > 0:
	print('>')
else:
	print('=')


import math
lt = list(map(int, input().split(' ')))
a = lt[0]
b = lt[1]
c = math.log(a)
c = c * b
d = math.log(b)
d = d * a
if c > d:
	print('>')
elif c < d:
	print('<')
else:
	print('=')


def main():
	(x, y) = [int(n) for n in input().strip().split(' ')]
	if x == y:
		return '='
	if x == 1:
		return '<'
	if y == 1:
		return '>'
	if x == 2 and y == 4 or (x == 4 and y == 2):
		return '='
	if x == 2 and y == 3:
		return '<'
	if x == 3 and y == 2:
		return '>'
	return '<' if x > y else '>'
print(main())


(x, y) = input().split()
x = int(x)
y = int(y)
if x == y or (x == 2 and y == 4) or (x == 4 and y == 2):
	print('=')
elif x > y:
	if y == 1:
		print('>')
	elif y == 2 and x < 5:
		print('>')
	else:
		print('<')
elif x == 1:
	print('<')
elif x == 2 and y < 5:
	print('<')
else:
	print('>')


from math import log
s = input().split()
(x, y) = (int(s[0]), int(s[1]))
s = y * log(x) - x * log(y)
if s > 0:
	print('>')
elif s < 0:
	print('<')
else:
	print('=')


from math import log
(x, y) = a = list(map(int, input().split()))
b = x * log(y)
a = y * log(x)
if a < b:
	print('<')
elif a > b:
	print('>')
else:
	print('=')


import math
(x, y) = list(map(int, input().split()))
(x1, y1) = (y * math.log(x), x * math.log(y))
if x1 > y1:
	print('>')
elif x1 < y1:
	print('<')
else:
	print('=')


from math import log
(x, y) = (int(i) for i in input().split())
f = y * log(x) - x * log(y)
if f < 0:
	print('<')
elif f == 0:
	print('=')
else:
	print('>')


from math import log
x = input().split()
x[0] = int(x[0])
x[1] = int(x[1])
a = log(x[0])
b = log(x[1])
c = x[0] * b
d = x[1] * a
if d > c:
	print('>')
elif d < c:
	print('<')
else:
	print('=')


import math
l = [int(x) for x in input().split()]
(x, y) = l
if x == y:
	print('=')
elif x != 1 and y != 1:
	if x / y < math.log(x) / math.log(y):
		print('>')
	elif x / y > math.log(x) / math.log(y):
		print('<')
	else:
		print('=')
elif x == 1:
	print('<')
else:
	print('>')


import math
(a, b) = map(int, input().split())
X = b * math.log(a)
Y = a * math.log(b)
if X > Y:
	print('>')
elif X < Y:
	print('<')
else:
	print('=')


from math import log
(x, y) = map(int, input().split())
a = x * log(y)
b = y * log(x)
if abs(a - b) < 0.001:
	print('=')
elif a > b:
	print('<')
else:
	print('>')


(x, y) = [int(i) for i in input().strip().split()]
if y > x:
	if x < y ** (x / y):
		print('<')
	elif x > y ** (x / y):
		print('>')
	else:
		print('=')
elif y == x:
	print('=')
elif y < x ** (y / x):
	print('>')
elif y > x ** (y / x):
	print('<')
else:
	print('=')


import math
(x, y) = map(int, input().split())
a = y * math.log(x)
b = x * math.log(y)
if abs(a - b) < 1e-08:
	print('=')
elif a < b:
	print('<')
else:
	print('>')


(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x == 2 and y == 3:
	print('<')
elif x == 3 and y == 2:
	print('>')
elif x == 2 and y == 4 or (x == 4 and y == 2):
	print('=')
elif x > y:
	print('<')
else:
	print('>')


from math import log
(a, b) = input().split()
(a, b) = (int(a), int(b))
x = a * log(b)
y = b * log(a)
if x > y:
	print('<')
elif x < y:
	print('>')
elif x == y:
	print('=')


import math as m
(x, y) = list(map(int, input().split(' ')))
a = y * m.log(x)
b = x * m.log(y)
if a == b:
	print('=')
elif a > b:
	print('>')
else:
	print('<')


import math
(x, y) = map(int, input().strip().split(' '))
if x == y or (x == 2 and y == 4) or (y == 2 and x == 4):
	print('=')
else:
	t = y * math.log(x * 1.0)
	tt = x * math.log(y * 1.0)
	if t > tt:
		print('>')
	else:
		print('<')


(x, y) = [int(s) for s in input().split()]
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x == 2:
	if y == 3:
		print('<')
	elif y == 4:
		print('=')
	else:
		print('>')
elif y == 2:
	if x == 3:
		print('>')
	elif x == 4:
		print('=')
	else:
		print('<')
elif x > y:
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split())
if math.log(x) / x > math.log(y) / y:
	print('>')
if math.log(x) / x < math.log(y) / y:
	print('<')
if math.log(x) / x == math.log(y) / y:
	print('=')


(x, y) = map(int, input().split())
if x == y:
	print('=')
elif min(x, y) == 2 and max(x, y) == 4:
	print('=')
elif x > y:
	if y == 1 or (y == 2 and x < 4):
		print('>')
	else:
		print('<')
elif x == 1 or (x == 2 and y < 4):
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split(' '))
if x == y:
	print('=')
elif x == 1 and y == 1:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif y > x * math.log(y, x):
	print('>')
elif y == x * math.log(y, x):
	print('=')
else:
	print('<')


import math

def func(a, b):
	x = b * math.log2(a)
	y = a * math.log2(b)
	if x > y:
		return '>'
	elif y > x:
		return '<'
	else:
		return '='
s = input().split()
print(func(int(s[0]), int(s[1])))


import sys
import math
import itertools
import collections

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

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

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

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

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return int(str(n)[::-1])

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base=3):
	newnumber = ''
	while number > 0:
		newnumber = str(number % base) + newnumber
		number //= base
	return newnumber
(x, y) = mi()
if y * math.log(x) < x * math.log(y):
	print('<')
elif y * math.log(x) > x * math.log(y):
	print('>')
else:
	print('=')


(a, b) = map(int, input().split())
import math
if a == 1:
	if b == 1:
		print('=')
	else:
		print('<')
elif b == 1:
	print('>')
elif math.log(a) / a == math.log(b) / b:
	print('=')
elif abs(a - 2.7) > abs(b - 2.7):
	print('<')
else:
	print('>')


import math
from bisect import bisect_left, bisect_right
Inf = int(1e+18) + 7

def tuple_input(type):
	return map(type, input().strip().split())

def prime_fact(x):
	res = list()
	d = 2
	while d * d <= x:
		if x % d == 0:
			r = 0
			while x % d == 0:
				x /= d
				r += 1
			res.append([d, r])
		d += 1
	if x > 1:
		res.append([x, 1])
	return res
(x, y) = map(int, input().strip().split())
fx = prime_fact(x)
fy = prime_fact(y)
for e in fx:
	e[1] *= y
for e in fy:
	e[1] *= x
if fx == fy:
	print('=')
	exit(0)
xy = y * math.log(x)
yx = x * math.log(y)
if xy < yx:
	print('<')
else:
	print('>')


import math
(x, y) = [int(x) for x in input().split()]
swap = False
if x == y:
	print('=')
	quit(0)
if x > y:
	(x, y) = (y, x)
	swap = True
v1 = math.log(x) / x
v2 = math.log(y) / y
if v1 > v2:
	print('>') if not swap else print('<')
elif v1 == v2:
	print('=')
else:
	print('<') if not swap else print('>')


from math import log
arr = [int(x) for x in input().split()]
x = arr[0]
y = arr[1]
resp = ''
if x == y:
	resp = '='
ylogx = y * log(x)
xlogy = x * log(y)
if ylogx == xlogy:
	resp = '='
elif ylogx > xlogy:
	resp = '>'
else:
	resp = '<'
print(resp)


from math import log

def go():
	(x, y) = (int(i) for i in input().split(' '))
	x_t = x
	x = y * log(x)
	y = x_t * log(y)
	if x > y:
		return '>'
	if x < y:
		return '<'
	return '='
print(go())


import math
(x, y) = (int(_) for _ in input().split(' '))
left = y * math.log(x)
right = x * math.log(y)
if left < right:
	print('<')
elif right < left:
	print('>')
else:
	print('=')


input = input()
inputs = input.split()
for i in range(len(inputs)):
	inputs[i] = int(inputs[i])
if inputs[0] == 2 and inputs[1] == 3:
	print('<')
elif inputs[1] == 2 and inputs[0] == 3:
	print('>')
elif inputs[0] == 1 and inputs[1] != 1:
	print('<')
elif inputs[1] == 1 and inputs[0] != 1:
	print('>')
elif inputs[0] == 2 and inputs[1] == 4 or (inputs[1] == 2 and inputs[0] == 4) or inputs[0] == inputs[1]:
	print('=')
elif inputs[0] > inputs[1]:
	print('<')
else:
	print('>')


from math import log
(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x == 1 or y == 1:
	print('<' if x < y else '>')
elif log(y, x) > y / float(x):
	print('<')
elif log(y, x) < y / float(x):
	print('>')
else:
	print('=')


(x, y) = map(int, input().split())
if sorted([x, y]) == [2, 4] or x == y:
	print('=')
elif 1 in [x, y]:
	if x == 1:
		print('<')
	else:
		print('>')
elif not (x == 3 and y == 2) and x > y or (x == 2 and y == 3):
	print('<')
else:
	print('>')


import math
(x, y) = map(lambda x: math.log(int(x)) / int(x), input().split())
print('<' if x < y else '>' if x > y else '=')


from math import *
from sys import stdin, stdout
(x, y) = stdin.readline().split()
x = int(x)
y = int(y)
if y * log(x) > x * log(y):
	stdout.write('>')
elif y * log(x) < x * log(y):
	stdout.write('<')
else:
	stdout.write('=')


from math import log
a = input().split()
b = log(int(a[0])) / int(a[0])
c = log(int(a[1])) / int(a[1])
if b > c:
	print('>')
elif b < c:
	print('<')
elif b == c:
	print('=')


import math
(x, y) = input().split()
x = int(x)
y = int(y)
if x < math.e and y < math.e:
	if x == y:
		print('=')
	if x > y:
		print('>')
	if x < y:
		print('<')
elif x > math.e and y > math.e:
	if x == y:
		print('=')
	if x > y:
		print('<')
	if x < y:
		print('>')
else:
	a = math.pow(x, 1 / x)
	b = math.pow(y, 1 / y)
	if a == b:
		print('=')
	if a > b:
		print('>')
	if a < b:
		print('<')


import math as m
(x, y) = map(float, input().split())
if x == y:
	print('=')
	exit()
a = m.log(x) / x
b = m.log(y) / y
if a > b:
	print('>')
elif a < b:
	print('<')
else:
	print('=')


from math import *
(a, b) = map(int, input().split())
t1 = b * log(a)
t2 = a * log(b)
if t1 > t2:
	print('>')
elif t1 < t2:
	print('<')
else:
	print('=')


from math import log
(x, y) = list(map(int, input().split()))
if x == 4 and y == 2 or (x == 2 and y == 4) or x == y:
	print('=')
	exit(0)
if y * log(x) > x * log(y):
	print('>')
else:
	print('<')


(x, y) = map(int, input().split())
ans = ''
if x < y:
	if x >= 3:
		ans = '>'
	elif x == 2:
		if y > 4:
			ans = '>'
		elif y == 4:
			ans = '='
		else:
			ans = '<'
	else:
		ans = '<'
elif x > y:
	if y >= 3:
		ans = '<'
	elif y == 2:
		if x > 4:
			ans = '<'
		elif x == 4:
			ans = '='
		else:
			ans = '>'
	else:
		ans = '>'
else:
	ans = '='
print(ans)


from math import log
(a, b) = input().split()
(a, b) = (int(a), int(b))
if b * log(a) > a * log(b):
	print('>')
elif b * log(a) < a * log(b):
	print('<')
else:
	print('=')


from math import log
(x, y) = list(map(int, input().split()))
if x == y or (min(x, y) == 2 and max(x, y) == 4):
	print('=')
elif x * log(y) > y * log(x):
	print('<')
else:
	print('>')


from math import log
(a, b) = [int(i) for i in input().split()]
x = log(a)
y = log(b)
if b * x == a * y:
	print('=')
elif x * b < a * y:
	print('<')
else:
	print('>')


import math
(x, y) = list(map(int, input().split(' ')))
if x == 1 and y == 1:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x <= 4 and y <= 4:
	(l, r) = (x ** y, y ** x)
	if l > r:
		print('>')
	elif l < r:
		print('<')
	else:
		print('=')
elif x <= 4 and y > 4:
	print('>')
elif y <= 4 and x > 4:
	print('<')
elif x > y:
	print('<')
elif x < y:
	print('>')
else:
	print('=')


from math import log
(a, b) = [int(x) for x in input().split()]
la = b * log(a)
lb = a * log(b)
if la > lb:
	print('>')
elif la < lb:
	print('<')
else:
	print('=')


(n, m) = map(int, input().split())
flag = 0
if n == m or (n == 2 and m == 4) or (m == 2 and n == 4):
	print('=')
elif n == 2 and m == 3:
	print('<')
elif n == 3 and m == 2:
	print('>')
elif n == 1 or m == 1:
	if n == 1:
		print('<')
	else:
		print('>')
elif m > n:
	print('>')
else:
	print('<')


from math import *
(x, y) = input().split()
x = float(x)
y = float(y)

def cmpDouble(a, b):
	EPS = 1e-12
	if a < b - EPS:
		return '<'
	if a > b + EPS:
		return '>'
	return '='
if x == y:
	print('=')
elif x == 1:
	print('<')
else:
	print(cmpDouble(y, x * log(y, x)))


def main():
	(x, y) = map(int, input().split())
	if x == y:
		print('=')
		return
	if x == 1:
		print('<')
		return
	if y == 1:
		print('>')
		return
	if x + y == 6:
		print('=')
		return
	if x == 3:
		print('>')
		return
	if y == 3:
		print('<')
		return
	if x < y:
		print('>')
	else:
		print('<')
main()


import math
(x, y) = [int(u) for u in input().split()]
a = y * math.log(x)
b = x * math.log(y)
if abs(a - b) < 1e-08:
	print('=')
elif a < b:
	print('<')
else:
	print('>')


(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif max(x, y) <= 20:
	a = x ** y
	b = y ** x
	if a < b:
		print('<')
	elif a == b:
		print('=')
	else:
		print('>')
elif x < y:
	print('>')
else:
	print('<')


import math as m
(x, y) = map(int, input().split())
a = y * m.log10(x)
b = x * m.log10(y)
if a == b:
	print('=')
elif a > b:
	print('>')
else:
	print('<')


(n, m) = [int(i) for i in input().split()]
if n == 2 and m == 4 or (m == 2 and n == 4):
	print('=')
elif n == m:
	print('=')
elif n == 1:
	print('<')
elif m == 1:
	print('>')
elif n == 2 and m == 3:
	print('<')
elif m == 2 and n == 3:
	print('>')
elif n > m:
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split())
xy = y * math.log(x)
yx = x * math.log(y)
if xy > yx:
	print('>')
elif xy < yx:
	print('<')
else:
	print('=')


import math
(x, y) = input().split(' ')
(x, y) = (int(x), int(y))
if x * math.log10(y) < y * math.log10(x):
	print('>')
elif x * math.log10(y) == y * math.log10(x):
	print('=')
else:
	print('<')


def f(l):
	g = lambda x: 1 / x if x > 2 else [0, 1 / 4][x - 1]
	r = list(map(g, l))
	if r[0] > r[1]:
		return '>'
	if r[0] < r[1]:
		return '<'
	return '='
l = list(map(int, input().split()))
print(f(l))


import math
(x, y) = map(int, input().split())
if x == y:
	print('=')
	exit()
xx = math.log(y)
yy = math.log(x)
if y * yy < x * xx:
	print('<')
elif y * yy > x * xx:
	print('>')
else:
	print('=')


import math
import sys

def _main(x, y):
	if x == y:
		print('=')
		return
	a = y * math.log(x)
	b = x * math.log(y)
	if a > b:
		print('>')
	elif a < b:
		print('<')
	else:
		print('=')
(x, y) = map(int, input().split())
_main(x, y)


import math
(x, y) = input().split()
x = int(x)
y = int(y)
if x == y:
	print('=')
else:
	z = y * math.log(x, 2)
	t = x * math.log(y, 2)
	if z > t:
		print('>')
	elif z < t:
		print('<')
	else:
		print('=')


import math
str = input()
a = int(str.split(' ')[0])
b = int(str.split(' ')[1])
xy = b * math.log(a)
yx = a * math.log(b)
if xy > yx:
	print('>')
elif yx > xy:
	print('<')
else:
	print('=')


(a, b) = map(int, input().split())
from math import log
p = b * log(a)
q = a * log(b)
if p > q:
	print('>')
elif p == q:
	print('=')
else:
	print('<')


(x, y) = map(int, input().split())
from math import log
t = y * log(x)
y = x * log(y)
if t > y:
	print('>')
elif y > t:
	print('<')
else:
	print('=')


(a, b) = map(int, input().strip().split())
if a == b:
	print('=')
	exit()
if a == 1:
	print('<')
	exit()
if b == 1:
	print('>')
	exit()
if a == 2 and b == 3:
	print('<')
	exit()
if a == 3 and b == 2:
	print('>')
	exit()
if a == 2 and b == 4:
	print('=')
	exit()
if a == 4 and b == 2:
	print('=')
	exit()
if b > a:
	print('>')
else:
	print('<')


from math import *
(a, b) = map(int, input().split())
c = b * log(a)
d = a * log(b)
print('=' if c == d else '>' if c > d else '<')


(a, b) = map(int, input().split())
import math as m
(c, d) = (b * m.log(a), a * m.log(b))
if c < d:
	print('<')
elif c > d:
	print('>')
else:
	print('=')


from math import log
(x, y) = [int(i) for i in input().split()]
x1 = y * log(x)
y1 = x * log(y)
if x1 > y1:
	print('>')
elif x1 < y1:
	print('<')
else:
	print('=')


[m, n] = [int(x) for x in input().split()]
k = m / n
import math
if n != 1:
	if math.log(k, n) > k - 1:
		print('>')
	elif math.log(k, n) < k - 1:
		print('<')
	else:
		print('=')
elif m > n:
	print('>')
else:
	print('=')


from math import log
now = input().split()
A = int(now[0])
B = int(now[1])
num1 = log(A) / A
num2 = log(B) / B
if num1 > num2:
	print('>')
if num1 < num2:
	print('<')
if num1 == num2:
	print('=')


import math
(x, y) = map(int, input().split())
a = y * math.log(x)
b = x * math.log(y)
if x - y is 0:
	print('=')
elif x is 2 and y is 4:
	print('=')
elif x is 4 and y is 2:
	print('=')
elif a < b:
	print('<')
else:
	print('>')


def solve(x, y):
	if x == y:
		return '='
	if 2 in [x, y] and 4 in [x, y]:
		return '='
	if x == 1:
		return '<'
	if y == 1:
		return '>'
	if x == 3 and y == 2:
		return '>'
	if x == 2 and y == 3:
		return '<'
	if x < y:
		return '>'
	return '<'
(x, y) = list(map(int, input().split()))
print(solve(x, y))


import math
(x, y) = map(int, input().split())
n1 = y * math.log(x)
n2 = x * math.log(y)
if abs(n1 - n2) < 1e-08:
	print('=')
elif n1 < n2:
	print('<')
else:
	print('>')


(x, y) = map(int, input().split())
if x + y < 100:
	val1 = x ** y
	val2 = y ** x
	print('=' if val1 == val2 else '<' if val1 < val2 else '>')
elif x == y:
	print('=')
elif (x < y or y == 1) and x > 1:
	print('>')
else:
	print('<')


from math import log as l
while True:
	inp = input().split()
	x = int(inp[0])
	y = int(inp[1])
	if x == y:
		print('=')
	elif y == 1:
		if x ** y > y ** x:
			print('>')
		elif x ** y < y ** x:
			print('<')
		else:
			print('=')
	elif l(x) / l(y) == x / y:
		print('=')
	elif l(x) / l(y) > x / y:
		print('>')
	else:
		print('<')
	break


from math import log

def main():
	(x, y) = map(int, input().split())
	a = y * log(x)
	b = x * log(y)
	print('>' if a > b else '=' if a == b else '<')
main()


import math
(a, b) = input().split()
(a, b) = (int(a), int(b))
(la, lb) = (math.log(a), math.log(b))
if a * lb == b * la:
	print('=')
elif a * lb > b * la:
	print('<')
else:
	print('>')


from math import log, e

def main():
	(x, y) = map(int, input().split())
	if x == y or (max(x, y) == 4 and min(x, y) == 2):
		print('=')
		return
	if y * log(x, e) > x * log(y, e):
		print('>')
		return
	print('<')
	return
main()


import math

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

def solve():
	(x, y) = input_ints()
	b = x * math.log(y)
	a = y * math.log(x)
	if a < b:
		print('<')
	elif a > b:
		print('>')
	else:
		print('=')
solve()


import math as m
(x, y) = [int(x) for x in input().split()]
(xx, yy) = (y * m.log2(x), x * m.log2(y))
if xx == yy:
	print('=')
elif xx < yy:
	print('<')
else:
	print('>')


def stepeny(a, b):
	if a == 1:
		if b == 1:
			return '='
		else:
			return '<'
	elif a == 2:
		if b == 1:
			return '>'
		elif b == 2:
			return '='
		elif b == 3:
			return '<'
		elif b == 4:
			return '='
		else:
			return '>'
	elif b == 1:
		return '>'
	elif b == 2:
		if a == 3:
			return '>'
		elif a == 4:
			return '='
		else:
			return '<'
	elif b > a:
		return '>'
	elif a == b:
		return '='
	else:
		return '<'
(x, y) = [int(i) for i in input().split()]
print(stepeny(x, y))


import math
(x, y) = input().split()
x = int(x)
y = int(y)
a = y * math.log(x)
b = x * math.log(y)
if abs(a - b) < 1e-09:
	print('=')
elif a > b:
	print('>')
else:
	print('<')


from math import log2
(x, y) = map(int, input().split())
if min(x, y) > 1:
	(logx, logy) = (log2(x), log2(y))
	(p1, p2) = (y * logx, x * logy)
	print('=' if p1 == p2 else '>' if p1 > p2 else '<')
else:
	(p1, p2) = (x ** y, y ** x)
	print('=' if p1 == p2 else '>' if p1 > p2 else '<')


(x, y) = map(int, input().split())
if x <= 5 and y <= 5 or x == 1 or y == 1:
	if x ** y < y ** x:
		print('<')
	elif x ** y == y ** x:
		print('=')
	else:
		print('>')
elif x > y:
	print('<')
elif x == y:
	print('=')
else:
	print('>')


from math import *
from sys import stdin, stdout
vals = list(map(int, stdin.readline().split()))
x = int(vals[0])
y = int(vals[1])
if y * log(x) > x * log(y):
	stdout.write('>')
elif y * log(x) < x * log(y):
	stdout.write('<')
else:
	stdout.write('=')


import math
(x, y) = list(map(int, input().strip().split(' ')))
y_x = x * math.log(y)
x_y = y * math.log(x)
if x_y > y_x:
	print('>')
if x_y < y_x:
	print('<')
if x_y == y_x:
	print('=')


from math import log
(n, m) = map(int, input().split())
if n == m:
	print('=')
elif n == 1:
	print('<')
elif m == 1:
	print('>')
else:
	n2 = n / m
	n3 = log(n, m)
	if n2 < n3:
		print('>')
	elif n2 > n3:
		print('<')
	else:
		print('=')


(x, y) = map(int, input().split())
ans = y - x
if y + x < 10:
	if x ** y == y ** x:
		print('=')
	elif x ** y < y ** x:
		print('<')
	else:
		print('>')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif ans == 0:
	print('=')
elif ans < 0:
	print('<')
else:
	print('>')


import math
(x, y) = list(map(int, input().split()))
if x == 2 and y == 4:
	print('=')
elif y == 2 and x == 4:
	print('=')
elif x == y:
	print('=')
elif y * math.log(x) < x * math.log(y):
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split())
lx = y * math.log(x)
ly = x * math.log(y)
if abs(lx - ly) <= 0:
	print('=')
elif lx > ly:
	print('>')
else:
	print('<')


import math
(x, y) = [int(j) for j in input().split()]
a = math.log10(x) * y
b = math.log10(y) * x
if a > b:
	print('>')
elif a == b:
	print('=')
else:
	print('<')


from math import log, e
k = input().split()
(x, y) = (int(k[0]), int(k[1]))
if log(x) / x > log(y) / y:
	print('>')
elif log(x) / x < log(y) / y:
	print('<')
else:
	print('=')


from math import log

def main():
	(x, y) = map(float, input().split())
	(x, y) = (log(x) * y, log(y) * x)
	print('=<>'[(x < y) - (x > y)])
main()


import math
(a, b) = input().split()
a = int(a)
b = int(b)
xa = math.log(a) / a
xb = math.log(b) / b
if xa > xb:
	print('>')
elif xb > xa:
	print('<')
else:
	print('=')


from math import log
(n, m) = map(int, input().split())
s = n * log(m)
f = m * log(n)
if f == s:
	print('=')
elif f > s:
	print('>')
else:
	print('<')


from math import *
import sys
(x, y) = map(int, input().split())
(a, b) = (x, y)
k = 1
if a == 1 or b == 1:
	if a == 1 and b == 1:
		print('=')
	elif a != 1:
		print('>')
	else:
		print('<')
	sys.exit(0)
if x > y:
	(x, y) = (y, x)
(xx, yy) = (x, y)
while xx < yy:
	k += 1
	xx *= x
if xx == yy and k * x == y:
	print('=')
else:
	aa = log(a, 2)
	bb = log(b, 2)
	if aa * b > bb * a:
		print('>')
	else:
		print('<')


import math

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

def getTransIntList(n):
	first = getIntList()
	m = len(first)
	result = [[0] * n for _ in range(m)]
	for i in range(m):
		result[i][0] = first[i]
	for j in range(1, n):
		curr = getIntList()
		for i in range(m):
			result[i][j] = curr[i]
	return result
(x, y) = getIntList()
left = y * math.log(x)
right = x * math.log(y)
if left < right:
	print('<')
elif left > right:
	print('>')
else:
	print('=')


from math import log
(a, b) = [int(x) for x in input().split()]
ans = 2
if b * log(a) > a * log(b):
	ans = 1
if b * log(a) < a * log(b):
	ans = 0
print(['<', '>', '='][ans])


from math import log10
(x, y) = map(int, input().split())
if abs(y * log10(x) - x * log10(y)) <= 0.001:
	print('=')
elif y * log10(x) < x * log10(y):
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split())

def f(x):
	if x:
		return math.log(x) / x
if f(x) < f(y):
	print('<')
elif f(y) < f(x):
	print('>')
elif x == y:
	print('=')
else:
	print('=')


(x, y) = (int(s) for s in input().split(' '))
if x == 2 and y == 4 or (x == 4 and y == 2) or x == y:
	print('=')
elif x == 1 or (x == 2 and y == 3) or (x > y and (y != 1 and (not (x == 3 and y == 2)))):
	print('<')
else:
	print('>')


from math import log
n = list(map(int, input().split()))
x = n[0]
y = n[1]
a = y * log(x)
b = x * log(y)
if a > b:
	print('>')
elif b > a:
	print('<')
elif a == b:
	print('=')


import math
(a, b) = map(int, input().split())
m = math.log(b) * a
n = math.log(a) * b
if m > n:
	print('<')
elif m < n:
	print('>')
else:
	print('=')


(x, y) = map(int, input().split())
if x == y or (x == 2 and y == 4) or (x == 4 and y == 2):
	print('=')
	exit(0)
if x > 2 and y > 2:
	if x > y:
		print('<')
	else:
		print('>')
	exit(0)
if x == 1:
	print('<')
	exit(0)
if y == 1:
	print('>')
	exit(0)
if x == 2:
	if y == 3:
		print('<')
	else:
		print('>')
	exit(0)
if y == 2:
	if x == 3:
		print('>')
	else:
		print('<')


import math
l = input().split()
x = int(l[0])
y = int(l[1])
a = math.log(x) / x
b = math.log(y) / y
if a > b:
	print('>')
elif a < b:
	print('<')
else:
	print('=')


(x, y) = map(int, input().split(' '))
if x == y:
	print('=')
elif x == 2 and y == 4 or (x == 4 and y == 2):
	print('=')
else:
	g = abs(x - y)
	x1 = min(x, y)
	y1 = max(x, y)
	if y1 >= g and x1 != 1 and (g != 1 or x1 != 2):
		smallest = y1
	else:
		smallest = x1
	if smallest == x:
		print('<')
	else:
		print('>')


from decimal import *
getcontext().prec = 1000
(x, y) = map(Decimal, input().split())
xy = y * x.ln()
yx = x * y.ln()
d = xy - yx
e = Decimal(10) ** (-900)
if -e < d and d < e:
	print('=')
elif d > 0:
	print('>')
else:
	print('<')


import math
(x, y) = [int(i) for i in input().split()]
lx = math.log2(x)
ly = math.log2(x)
if x == y:
	print('=')
elif x > math.e and y > math.e:
	if x < y:
		print('>')
	else:
		print('<')
elif x < math.e and y < math.e:
	if x ** y < y ** x:
		print('<')
	elif x ** y == y ** x:
		print('=')
	else:
		print('>')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x == 2:
	if y == 3:
		print('<')
	elif y == 4:
		print('=')
	else:
		print('>')
elif y == 2:
	if x == 3:
		print('>')
	elif x == 4:
		print('=')
	else:
		print('<')


def ans(x, y):
	if x == y or (x, y) in [(2, 4), (4, 2)]:
		return '='
	if x == 1:
		return '<'
	if y == 1:
		return '>'
	if y == 3:
		return '<'
	if x == 3:
		return '>'
	if y < x:
		return '<'
	if y > x:
		return '>'
(x, y) = map(int, input().split())
print(ans(x, y))


import sys
from math import *
input = sys.stdin.buffer.readline
(x, y) = map(int, input().split())
v1 = y * log(x)
v2 = x * log(y)
if v1 < v2:
	print('<')
elif v1 > v2:
	print('>')
else:
	print('=')


import math
aux = input().split(' ')
x = int(aux[0])
y = int(aux[1])
if x == y:
	print('=')
else:
	x2 = y * math.log(x)
	y2 = x * math.log(y)
	if x2 == y2:
		print('=')
	elif x2 > y2:
		print('>')
	else:
		print('<')


import math as m
(x, y) = map(int, input().split())
x_y = y * m.log(x)
y_x = x * m.log(y)
if x_y > y_x:
	print('>')
elif x_y < y_x:
	print('<')
else:
	print('=')


(x, y) = map(int, input().split())
if max(x, y) < 200000:
	px = pow(x, y)
	py = pow(y, x)
	if px > py:
		print('>')
	if px < py:
		print('<')
	if px == py:
		print('=')
elif x == 1 and y != 1:
	print('<')
elif y == 1 and x != 1:
	print('>')
elif x == y:
	print('=')
elif x < y:
	print('>')
else:
	print('<')


import math
(x, y) = map(int, input().split())
c = y * math.log(x)
d = x * math.log(y)
if abs(c - d) < 1e-08:
	print('=')
elif c < d:
	print('<')
else:
	print('>')


from math import *
(x, y) = list(map(int, input().split()))
if y * log(x) - x * log(y) == 0:
	print('=')
elif y * log(x) - x * log(y) > 0:
	print('>')
else:
	print('<')


(x, y) = map(int, input().split())
if sorted([x, y]) == [2, 3]:
	if x == 2:
		print('<')
	else:
		print('>')
elif sorted([x, y]) == [2, 4]:
	print('=')
elif x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x < y:
	print('>')
else:
	print('<')


import math
(x, y) = map(lambda x: math.log(int(x)) / int(x), input().split())
print('<=>'[(x >= y) + (x > y)])


import math
(x, y) = map(int, input().split())
a = y * math.log(x)
b = x * math.log(y)
if a == b:
	print('=')
if a < b:
	print('<')
if a > b:
	print('>')


import math
(x, y) = [int(x) for x in input().split()]
k1 = math.log(y) * x
k2 = math.log(x) * y
if k1 > k2:
	print('<')
elif k1 < k2:
	print('>')
else:
	print('=')


from math import log
(x, y) = [int(i) for i in input().split()]
lhs = y * log(x)
rhs = x * log(y)
if lhs == rhs:
	print('=')
elif lhs > rhs:
	print('>')
elif rhs > lhs:
	print('<')


s = input().split(' ')
x = int(s[0])
y = int(s[1])
if 0 < x < 4:
	if 0 < y < 4:
		if x > y:
			print('>')
		if x == y:
			print('=')
		if x < y:
			print('<')
	else:
		if x == 1:
			print('<')
		if x == 2:
			if y > 4:
				print('>')
			if y == 4:
				print('=')
		if x == 3:
			print('>')
elif 0 < y < 4:
	if y == 1:
		print('>')
	if y == 2:
		if x > 4:
			print('<')
		if x == 4:
			print('=')
	if y == 3:
		print('<')
else:
	if x > y:
		print('<')
	if x == y:
		print('=')
	if x < y:
		print('>')


import math

def main():
	(x, y) = [int(t) for t in input().split()]
	if x == y and x == 1:
		print('=')
	elif x == 1:
		print('<')
	elif y == 1:
		print('>')
	elif y > x * math.log(y, x):
		print('>')
	elif y < x * math.log(y, x):
		print('<')
	else:
		print('=')
main()


from math import log as l1
strr = list(map(int, input().split()))
x = strr[0]
y = strr[1]
val1 = y * l1(x)
val2 = x * l1(y)
if val1 > val2:
	print('>')
elif val2 > val1:
	print('<')
else:
	print('=')


from math import *
(x, y) = map(int, input().split())
t2 = x * log(y)
t1 = y * log(x)
if t1 == t2:
	print('=')
if t1 > t2:
	print('>')
if t1 < t2:
	print('<')


from math import log
(a, b) = map(int, input().split())
if a == b == 1:
	print('=')
	exit()
elif a == 1:
	print('<')
	exit()
elif b == 1:
	print('>')
	exit()
if b > a * log(b, a):
	print('>')
elif b < a * log(b, a):
	print('<')
else:
	print('=')


import math
(x, y) = list(map(int, input().strip().split()))
if y * math.log(x) > x * math.log(y):
	print('>')
elif y * math.log(x) < x * math.log(y):
	print('<')
else:
	print('=')


(a, b) = map(int, input().split())
if a == b:
	print('=')
elif a == 1:
	print('<')
elif b == 1:
	print('>')
elif (a, b) == (2, 4):
	print('=')
elif (a, b) == (4, 2):
	print('=')
elif (a, b) == (2, 3):
	print('<')
elif (a, b) == (3, 2):
	print('>')
else:
	print('<' if a > b else '>')


import math
gg = 'abcdefghijklmnopqrstuvwxyz'
(n, m) = map(int, input().split())
a = m * math.log(n)
b = n * math.log(m)
if a > b:
	print('>')
if a == b:
	print('=')
if a < b:
	print('<')


import math

def power(x, y):
	if y == 0:
		return 1
	temp = power(x, int(y / 2))
	if y % 2 == 0:
		return temp * temp
	elif y > 0:
		return x * temp * temp
	else:
		return temp * temp / x
(x, y) = map(int, input().split())
if x == y:
	print('=')
else:
	a1 = y * math.log(x)
	a2 = x * math.log(y)
	if a1 > a2:
		print('>')
	if a1 < a2:
		print('<')
	if a1 == a2:
		print('=')


from math import log
(a, b) = [int(x) for x in input().split()]
if b * log(a, 2) > a * log(b, 2):
	print('>')
elif b * log(a, 2) == a * log(b, 2):
	print('=')
else:
	print('<')


import math

def fun1(str):
	x = int(str.split(' ')[0])
	y = int(str.split(' ')[1])
	if x == y or y * math.log2(x) == x * math.log2(y):
		print('=')
		return
	tmp = '>' if y * math.log2(x) > x * math.log2(y) else '<'
	print(tmp)
str = input()
fun1(str)


from math import log
(x, y) = map(int, input().split())
(l, r) = (log(x) / x, log(y) / y)
if l < r:
	print('<')
elif l > r:
	print('>')
else:
	print('=')


from decimal import Decimal, getcontext
import math
getcontext().prec = 200
(x, y) = list(map(int, input().split()))
xy = Decimal(y) * Decimal(x).ln()
yx = Decimal(x) * Decimal(y).ln()
if abs(xy - yx) < Decimal(0.1) ** Decimal(20):
	print('=')
elif xy < yx:
	print('<')
else:
	print('>')


import sys
from math import log

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for k in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
EPS = 10 ** (-10)
(x, y) = MAP()
xy = log(x) * y
yx = log(y) * x
if xy < yx - EPS:
	print('<')
elif xy - EPS > yx:
	print('>')
else:
	print('=')


from math import log
(x, y) = map(int, input().split())
(a, b) = (y * log(x), x * log(y))
ans = '>' if a > b else '<' if a < b else '='
print(ans)


import sys
from math import log
input = sys.stdin.readline
(X, Y) = map(int, input().split())
xy = Y * log(X)
yx = X * log(Y)
if xy < yx:
	print('<')
elif xy > yx:
	print('>')
else:
	print('=')


import math
(x, y) = map(int, input().split())
sum1 = math.log10(x) * y
sum2 = math.log10(y) * x
if sum1 == sum2:
	print('=')
elif sum1 > sum2:
	print('>')
else:
	print('<')


import math
l = input().split()
x = int(l[0])
y = int(l[1])
if x < y and x >= 3:
	print('>')
if y < x and y >= 3:
	print('<')
if x == y:
	print('=')
if x == 2 and y == 3:
	print('<')
if x == 3 and y == 2:
	print('>')
if x == 2 and y == 4 or (x == 4 and y == 2):
	print('=')
if x == 1 and y == 2:
	print('<')
if x == 2 and y == 1:
	print('>')
if x == 1 and y >= 3:
	print('<')
if x >= 3 and y == 1:
	print('>')
if x == 2 and y >= 5:
	print('>')
if y == 2 and x >= 5:
	print('<')


(x, y) = list(map(int, input().split()))
from math import log
(xx, yy) = (log(x) / x, log(y) / y)
if xx > yy:
	print('>')
elif xx < yy:
	print('<')
else:
	print('=')


import math
from decimal import *
l1 = input().split()
l1 = [int(i) for i in l1]
x = l1[0]
y = l1[1]
a = y * math.log10(x)
b = x * math.log10(y)
if a == b:
	print('=')
elif a > b:
	print('>')
else:
	print('<')


from math import log
X = list(map(int, input().split()))
(X[0], X[1]) = (X[1] * log(X[0]), X[0] * log(X[1]))
print('<' if X[1] > X[0] else '=' if X[1] == X[0] else '>')


import math

def func():
	lis = input().rstrip().lstrip().split(' ')
	(x, y) = [float(item) for item in lis]
	if x == y:
		print('=')
		return
	p = y * math.log(x)
	q = x * math.log(y)
	if p < q:
		print('<')
	elif p > q:
		print('>')
	else:
		print('=')
func()


xx = str(input())
xx = xx.split(' ')
for i in range(0, 2):
	xx[i] = int(xx[i])
x = xx[0]
y = xx[1]
if x == y or (x == 2 and y == 4) or (x == 4 and y == 2):
	print('=')
	exit()
if x > y and x >= 5:
	if y == 1:
		print('>')
	else:
		print('<')
	exit()
if x < y and y >= 5:
	if x == 1:
		print('<')
	else:
		print('>')
	exit()
if x == 3:
	print('>')
if y == 3:
	print('<')
if x == 1:
	print('<')
if y == 1:
	print('>')


(x, y) = list(map(int, input().split()))
if x == y:
	print('=')
elif min(x, y) == 1:
	if x > y:
		print('>')
	else:
		print('<')
elif min(x, y) == 2:
	if max(x, y) == 3:
		if x == 2:
			print('<')
		else:
			print('>')
	elif max(x, y) == 4:
		print('=')
	elif x == 2:
		print('>')
	else:
		print('<')
elif x == min(x, y):
	print('>')
else:
	print('<')


import math as M
(x, y) = map(int, input().split())
a = M.log(x) * y
b = M.log(y) * x
print('>' if a > b else '<' if a < b else '=')


from math import log
(x, y) = [int(i) for i in input().split()]
m = x * log(y)
n = y * log(x)
if m < n:
	print('>')
elif m > n:
	print('<')
else:
	print('=')


s = list(map(int, input().split()))
x = s[0]
y = s[1]
if x == y:
	print('=')
if x > y and x > 2 and (y > 2):
	print('<')
if x > y and x <= 3 and (y <= 3):
	print('>')
if x < y and x > 2 and (y > 2):
	print('>')
if x < y and x <= 3 and (y <= 3):
	print('<')
if x == 1 and y != 1:
	print('<')
if x != 1 and y == 1:
	print('>')
if x == 2 and y == 4 or (x == 4 and y == 2):
	print('=')
if x == 2 and y > 4:
	print('>')
if x > 4 and y == 2:
	print('<')


import os
import sys
import math
(x, y) = input().strip().split(' ')
(x, y) = [int(x), int(y)]
a = y * math.log(x, math.e)
b = x * math.log(y, math.e)
if a == b:
	print('=')
elif a > b:
	print('>')
elif a < b:
	print('<')


(a, b) = map(int, input().split())
import math as m
res1 = b * m.log(a)
res2 = a * m.log(b)
print('>' if res1 > res2 else '<' if res2 > res1 else '=')


import math
xy = input().split(' ')
x = int(xy[0])
y = int(xy[1])
p = round(y * math.log(x), 5)
q = round(x * math.log(y), 5)
if p > q:
	print('>')
elif p == q:
	print('=')
else:
	print('<')


(x, y) = [int(i) for i in input().split()]
if x == 1:
	if y == 1:
		print('=')
	else:
		print('<')
elif y == 1:
	print('>')
else:
	import math
	eps = 10 ** (-16)
	a = y / x
	b = math.log(y) / math.log(x)
	c = a + eps
	d = b - eps
	f = a - eps
	e = b + eps
	if c > d and f > e:
		print('>')
	elif c < d and f < e:
		print('<')
	else:
		print('=')


import math
(a, b) = map(int, input().split())
aaa = b * math.log(a)
bbb = a * math.log(b)
if aaa > bbb:
	print('>')
elif aaa < bbb:
	print('<')
else:
	print('=')


import math

def main():
	(x, y) = map(int, input().split())
	expV = x / y * math.log(y)
	if math.log(x) == expV:
		print('=')
	elif math.log(x) < expV:
		print('<')
	else:
		print('>')
main()


(a, b) = map(int, input().split())
x = a > b
y = min(a, b)
if a == b:
	print('=')
elif y == 1:
	if x:
		print('>')
	else:
		print('<')
elif a * b < 8:
	if x:
		print('>')
	else:
		print('<')
elif a * b == 8:
	print('=')
elif x:
	print('<')
else:
	print('>')


import math
(n, m) = [int(x) for x in input().split(' ')]
if m * math.log10(n) > n * math.log10(m):
	print('>')
elif m * math.log10(n) < n * math.log10(m):
	print('<')
else:
	print('=')


from math import log
(a, b) = map(int, input().split())
a1 = b * log(a)
a2 = a * log(b)
if a1 < a2:
	print('<')
if a1 == a2:
	print('=')
if a1 > a2:
	print('>')


def solve(x, y):
	if x == y:
		return '='
	if min(x, y) == 1:
		return '<' if x == 1 else '>'
	if max(x, y) == 4 and min(x, y) == 2:
		return '='
	if min(x, y) == 2 and max(x, y) == 3:
		return '<' if x == 2 else '>'
	if max(x, y) < 3:
		return '>' if x > y else '<'
	else:
		return '<' if x > y else '>'
(x, y) = map(int, input().split())
print(solve(x, y))


from math import log
(a, b) = map(int, input().split())

def f(a, b):
	if a == b:
		return '='
	elif a < b:
		return '<'
	else:
		return '>'
if a < 100 and b < 100:
	print(f(a ** b, b ** a))
elif a == b:
	print(f(a, b))
else:
	print(f(b * log(a), a * log(b)))


(x, y) = map(int, input().split())
if x < 10 and y < 10:
	a = x ** y
	b = y ** x
	if a > b:
		print('>')
	elif a < b:
		print('<')
	else:
		print('=')
elif x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x > y:
	print('<')
else:
	print('>')


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

def f(a, b):
	if a > b:
		return '><'
	elif a < b:
		return '<>'
	else:
		return '=='
(a, b) = inp()
if a == 1 and b == 1:
	print('=')
elif a == 1 and b != 1:
	print('<')
elif a != 1 and b == 1:
	print('>')
elif a <= 10 and b <= 10:
	print(f(a ** b, b ** a)[0])
else:
	print(f(a, b)[-1])


(x, y) = map(int, input().split())
if x == 1 or y == 1:
	if x > 1:
		print('>')
	elif y > 1:
		print('<')
	else:
		print('=')
	exit()
if x < 10 and y < 10:
	if x ** y > y ** x:
		print('>')
	elif x ** y < y ** x:
		print('<')
	else:
		print('=')
elif x < y:
	print('>')
elif x > y:
	print('<')
else:
	print('=')


import math
(x, y) = input().split(' ')
x = int(x)
y = int(y)
tempx = y * math.log(x)
tempy = x * math.log(y)
if tempx > tempy:
	print('>')
elif tempx < tempy:
	print('<')
else:
	print('=')


import decimal
from decimal import Decimal
from math import log
decimal.getcontext().prec = 10
read = input()
l = read.split()
if l[0] == '1':
	if '1' < l[1]:
		print('<')
	elif l[1] == '1':
		print('=')
	else:
		print('>')
	exit()
a = float(l[0])
b = float(l[1])
c = Decimal.from_float(a) / Decimal.from_float(b) * Decimal.from_float(log(b, a))
if 1 < c:
	print('<')
elif c == Decimal('1.0'):
	print('=')
else:
	print('>')


(x, y) = map(int, input().split())
if x == y or (x == 2 and y == 4) or (x == 4 and y == 2):
	print('=')
	exit()
if x == 1:
	print('<')
	exit()
if y == 1:
	print('>')
	exit()
if x > y:
	if y > 2 or x > 4:
		print('<')
		exit()
	print('>')
	exit()
if x < y:
	if x > 2 or y > 4:
		print('>')
		exit()
	print('<')
	exit()
exit(100500)


import math

def abcd(x, y):
	if x == 1:
		if y == x:
			print('=')
			return
		else:
			print('<')
			return
	z = y - x * math.log(y, x)
	if z > 0:
		print('>')
	elif z < 0:
		print('<')
	else:
		print('=')
	return
(x, y) = (float(i) for i in input().split(' '))
abcd(x, y)


import cmath
(x, y) = map(int, input().split())
if x == 1 or y == 1:
	if x > y:
		print('>')
	elif x < y:
		print('<')
	else:
		print('=')
	exit(0)
a = float(str(cmath.log(x, 2))[1:-4]) * y
b = float(str(cmath.log(y, 2))[1:-4]) * x
if a > b:
	print('>')
elif a == b:
	print('=')
else:
	print('<')


from decimal import *
s = input().split()
a = int(s[0])
b = int(s[1])
x = b * Decimal(a).ln()
y = a * Decimal(b).ln()
if x > y:
	print('>')
elif x == y:
	print('=')
else:
	print('<')


import math
(x, y) = map(int, input().split())
k1 = y * math.log10(x)
k2 = x * math.log10(y)
if k1 > k2:
	print('>')
elif k2 > k1:
	print('<')
else:
	print('=')


from math import log
(x, y) = [int(i) for i in input().split()]
lef = y * log(x)
righ = x * log(y)
if lef < righ:
	print('<')
elif lef > righ:
	print('>')
else:
	print('=')


t = [int(e.strip()) for e in input().split(' ')]
x = t[0]
y = t[1]
import math
value = y * math.log(x) - x * math.log(y)
if abs(value) < 1e-06:
	print('=')
elif value < 0:
	print('<')
else:
	print('>')


import math
(x, y) = list(map(float, input().split()))
l = math.log(y, x) * x
if y == l or y == x:
	print('=')
elif y > l:
	print('>')
else:
	print('<')


import math
(x, y) = map(int, input().split())
(c1, c2) = (math.log(x) / x, math.log(y) / y)
print('<' if c1 < c2 else '>' if c1 > c2 else '=')


from collections import *
import sys
import math
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input())

def stli():
	return [int(i) for i in input().rstrip('\n')]
(x, y) = li()
if x == y:
	print('=')
elif abs(x - y) <= 2 and x < 110:
	if x ** y < y ** x:
		print('<')
	elif x ** y != y ** x:
		print('>')
	else:
		print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x < y:
	print('>')
elif x > y:
	print('<')


from math import *
(x, y) = map(int, input().split())
if x > y:
	if pow(x, y / x) > y:
		print('>')
	elif pow(x, y / x) < y:
		print('<')
	else:
		print('=')
elif x < y:
	if x > pow(y, x / y):
		print('>')
	elif x < pow(y, x / y):
		print('<')
	else:
		print('=')
else:
	print('=')


import math
(x, y) = [int(v) for v in input().split()]
xly = x * math.log(y)
ylx = y * math.log(x)
if abs(xly - ylx) < 1e-08:
	print('=')
elif ylx < xly:
	print('<')
else:
	print('>')


(x, y) = map(float, input().split())
import math
u = y * math.log(x)
v = x * math.log(y)
if u > v:
	print('>')
elif u < v:
	print('<')
else:
	print('=')


import math
n = input().split()
x = int(n[0])
y = int(n[1])
if y * math.log(x) > x * math.log(y):
	print('>')
elif y * math.log(x) < x * math.log(y):
	print('<')
else:
	print('=')


import math
(x, y) = list(map(int, input().split()))
flag = False
if x > y:
	(x, y) = (y, x)
	flag = True
if x == y:
	print('=')
elif x == 1:
	if flag:
		print('>')
	else:
		print('<')
elif x == 2 and y == 4:
	print('=')
else:
	if flag:
		(x, y) = (y, x)
	if y > x * math.log(y) / math.log(x):
		print('>')
	else:
		print('<')


import math
(x, y) = [int(x) for x in input().split()]
x_logy = x * math.log(y)
y_logx = y * math.log(x)
if x_logy == y_logx:
	print('=')
elif x_logy > y_logx:
	print('<')
else:
	print('>')


a = [int(k) for k in input().split()]
x = a[0]
y = a[1]
if x == y or (x, y) == (2, 4) or (x, y) == (4, 2):
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif (x, y) == (2, 3):
	print('<')
elif (x, y) == (3, 2):
	print('>')
elif x > y:
	print('<')
else:
	print('>')


from math import log
inp = list(map(int, input().split()))
t = inp[1] * log(inp[0])
z = inp[0] * log(inp[1])
if t > z:
	print('>')
elif t < z:
	print('<')
else:
	print('=')


import sys
(a, b) = map(int, input().split())
list = [a, b]
if a < b and b > 1000:
	print('>')
	sys.exit()
if a > b and b != 1 and (a > 1000):
	print('<')
	sys.exit()
if a == 1000000000 and b == 2:
	print('<')
	sys.exit()
if a > 1000 and b > 1000:
	if a < b:
		print('>')
		sys.exit()
	elif a > b:
		print('<')
		sys.exit()
	elif a == b:
		print('=')
		sys.exit()
wynik_a = a ** b
wynik_b = b ** a
if wynik_a > wynik_b:
	print('>')
elif wynik_a < wynik_b:
	print('<')
elif wynik_a == wynik_b:
	print('=')


import math
(X, Y) = map(int, input().split())
if X == 1 or Y == 1:
	XY = X ** Y
	YX = Y ** X
	if XY > YX:
		print('>')
	elif XY < YX:
		print('<')
	else:
		print('=')
else:
	if X >= Y:
		XY = Y
		YX = X * math.log(Y, X)
		if XY > YX:
			print('>')
		elif XY < YX:
			print('<')
		else:
			print('=')
	if X < Y:
		XY = Y * math.log(X, Y)
		YX = X
		if XY > YX:
			print('>')
		elif XY < YX:
			print('<')
		else:
			print('=')


inp = [int(x) for x in input().split(' ')]
x = inp[0]
y = inp[1]

def showRes(res, swapped):
	if res == 1 and (not swapped) or (res != 1 and swapped):
		print('>')
	else:
		print('<')
if x == y:
	print('=')
	exit(0)
swapped = False
if x > y:
	swapped = True
	tmp = x
	x = y
	y = tmp
t = y / x
u = t ** (1 / (t - 1))
if x == u:
	print('=')
elif x > u:
	showRes(1, swapped)
else:
	showRes(-1, swapped)


import math
(x, y) = map(int, input().split())
xInTermsY = math.log(x, y)
if xInTermsY * y > x:
	print('>')
elif xInTermsY * y < x:
	print('<')
else:
	print('=')


import math
(x, y) = map(int, input().split())
if x == y or (x, y) == (2, 4) or (x, y) == (4, 2):
	print('=')
elif x == 1 or y == 1:
	if x == 1:
		print('<')
	else:
		print('>')
else:
	sw = False
	if x > y:
		(x, y) = (y, x)
		sw = True
	if x != 2:
		le = False
	elif y == 3:
		le = True
	else:
		le = False
	if le != sw:
		print('<')
	else:
		print('>')


import math
a = input()
a = a.split(' ')
a[0] = int(a[0])
a[1] = int(a[1])
if math.log10(a[0]) * a[1] > math.log10(a[1]) * a[0]:
	print('>')
elif math.log10(a[0]) * a[1] < math.log10(a[1]) * a[0]:
	print('<')
else:
	print('=')


from math import log
(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
else:
	xLog = y * log(x)
	yLog = x * log(y)
	if xLog == yLog:
		print('=')
	elif xLog < yLog:
		print('<')
	else:
		print('>')


(x, y) = map(int, input().split())
if y == 1 and x != 1:
	print('>')
	exit()
if x == 1 and y != 1:
	print('<')
	exit()
if sorted([x, y]) == [2, 4]:
	print('=')
	exit()
if x == 2 and y == 3:
	print('<')
	exit()
if x == 3 and y == 2:
	print('>')
	exit()
if x == y:
	print('=')
elif x < y:
	print('>')
elif x > y:
	print('<')


import math
i = input().split()
(x, y) = (int(i[0]), int(i[1]))
xey = y * math.log(x)
yex = x * math.log(y)
if xey == yex:
	print('=')
elif xey < yex:
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split())
if x == 1 and y == 1:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif (x == 2 or x == 4) and (y == 2 or y == 4):
	print('=')
elif x == y:
	print('=')
elif x == 3 and y == 2:
	print('>')
elif x == 2 and y == 3:
	print('<')
elif min(x, y) == x:
	print('>')
else:
	print('<')


a = input()
b = a.split()
num1 = int(b[0])
num2 = int(b[1])
if num1 == num2:
	print('=')
	raise SystemExit(0)
if num1 > 2 and num2 > 2:
	if num1 > num2:
		print('<')
		raise SystemExit(0)
	else:
		print('>')
		raise SystemExit(0)
elif num1 == 1:
	print('<')
	raise SystemExit(0)
elif num2 == 1:
	print('>')
	raise SystemExit(0)
elif num1 + num2 <= 5:
	if num1 < num2:
		print('<')
		raise SystemExit(0)
	else:
		print('>')
		raise SystemExit(0)
elif num1 + num2 == 6:
	print('=')
	raise SystemExit(0)
elif num1 > num2:
	print('<')
	raise SystemExit(0)
else:
	print('>')
	raise SystemExit(0)


(a, b) = map(int, input().split())
if a == b:
	print('=')
elif a == 0:
	print('<')
elif b == 0:
	print('>')
elif b > a:
	b = b ** (a / b)
	if b > a:
		print('<')
	elif b == a:
		print('=')
	else:
		print('>')
else:
	a = a ** (b / a)
	if b > a:
		print('<')
	elif b == a:
		print('=')
	else:
		print('>')


(x, y) = map(int, input().split())
if x == 1 and y == 1:
	print('=')
elif x == 1 and y > 1:
	print('<')
elif x > 1 and y == 1:
	print('>')
elif x <= 100 and y <= 100:
	if x ** y > y ** x:
		print('>')
	elif x ** y < y ** x:
		print('<')
	else:
		print('=')
elif x > y:
	print('<')
elif x < y:
	print('>')
else:
	print('=')


import math
(a, b) = map(int, input().split())
if b * math.log10(a) - a * math.log10(b) > 0:
	print('>')
elif b * math.log10(a) - a * math.log10(b) < 0:
	print('<')
else:
	print('=')


(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x + y == 6:
	print('=')
elif x == 3:
	print('>')
elif y == 3:
	print('<')
elif x < y:
	print('>')
else:
	print('<')


from math import log, pow
(x, y) = map(int, input().split())
r = x * log(y, 10)
z = y * log(x, 10)
if r == z:
	print('=')
elif r > z:
	print('<')
else:
	print('>')


TN = 1

def solution():
	from math import log10
	(x, y) = map(int, input().split())
	(a, b) = (y * log10(x), x * log10(y))
	if a < b:
		print('<')
	elif a > b:
		print('>')
	else:
		print('=')
while TN != 0:
	solution()
	TN -= 1


(x, y) = [int(x) for x in input().split()]
mock = dict()
for i in range(100):
	for j in range(100):
		mock[i, j] = '<' if i ** j < j ** i else '=' if i ** j == j ** i else '>'
try:
	print(mock[x, y])
except:
	if x == y:
		print('=')
	elif x == 1:
		print('<')
	elif y == 1:
		print('>')
	else:
		print('>' if x < y else '<')


import math
(x, y) = map(float, input().split())
if x == y:
	print('=')
elif x == 1 or y == 1:
	if x == 1:
		print('<')
	else:
		print('>')
elif math.log10(x) / x > math.log10(y) / y:
	print('>')
elif math.log10(x) / x < math.log10(y) / y:
	print('<')
else:
	print('=')


import math
(x, y) = map(int, input().split())
ans1 = math.log(x) / x
ans2 = math.log(y) / y
if ans1 > ans2:
	print('>')
elif ans1 < ans2:
	print('<')
else:
	print('=')


import math

def main():
	(x, y) = list(map(int, input().split()))
	k = y * math.log(x) - x * math.log(y)
	if k == 0:
		print('=')
	else:
		print('>' if k > 0 else '<')
main()


import math
(x, y) = [int(s) for s in input().split(' ')]
if math.log10(x) / x > math.log10(y) / y:
	print('>')
elif math.log10(x) / x < math.log10(y) / y:
	print('<')
else:
	print('=')


import math
arr = input().split()
x = int(arr[0])
y = int(arr[1])
if math.fabs(y * math.log(x) - x * math.log(y)) < 1e-08:
	print('=')
elif y * math.log(x) < x * math.log(y):
	print('<')
else:
	print('>')


import math
(x, y) = list(map(lambda x: int(x), input().split()))
(a, b) = (math.log(x), math.log(y))
diff = x * b - y * a
if diff > 0:
	print('<')
elif diff == 0:
	print('=')
else:
	print('>')


(x, y) = list(map(int, input().split()))
import math
p = math.log2(x)
q = math.log2(y)
if p * y < q * x:
	print('<')
elif p * y > q * x:
	print('>')
else:
	print('=')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

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 pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def main():
	(x, y) = LI()
	if x == y:
		return '='
	if x < 10 and y < 10:
		t = x ** y
		u = y ** x
		if t > u:
			return '>'
		if t < u:
			return '<'
		return '='
	if x == 1:
		return '<'
	if y == 1:
		return '>'
	if x > y:
		return '<'
	return '>'
print(main())


import math
(x, y) = list(map(int, input().split(' ')))
if x == 1 and y > 1:
	print('<')
elif x > 1 and y == 1:
	print('>')
elif x == y:
	print('=')
elif math.log2(x) / math.log2(y) > x / y:
	print('>')
elif math.log2(x) / math.log2(y) < x / y:
	print('<')
else:
	print('=')


(a, b) = map(int, input().split())
ok = True
if a > b:
	(a, b) = (b, a)
	ok = False
if a == b or (a == 2 and b == 4):
	print('=')
elif a < 2 or (a == 2 and b == 3):
	if ok:
		print('<')
	else:
		print('>')
elif ok:
	print('>')
else:
	print('<')


import sys
from math import log
for line in sys.stdin:
	(a, b) = line.strip().split()
	(a, b) = (int(a), int(b))
	if b * log(a) < a * log(b):
		print('<')
	elif b * log(a) == a * log(b):
		print('=')
	else:
		print('>')


from math import log
(x, y) = map(int, input().split())
d = y * log(x) - x * log(y)
print('<>'[d > 0] if d else '=')


import math
l = input().strip().split()
x = int(l[0])
y = int(l[1])
if y * math.log(x) > x * math.log(y):
	print('>')
elif y * math.log(x) == x * math.log(y):
	print('=')
else:
	print('<')


import math
inp = input().split(' ')
x = int(inp[0])
y = int(inp[1])
res1 = y * math.log(1.0 * x)
res2 = x * math.log(1.0 * y)
if res1 == res2:
	print('=')
elif res1 > res2:
	print('>')
else:
	print('<')


import math
listt = [int(x) for x in input().split()]
x = listt[0]
y = listt[1]
x1 = y * math.log(x)
y1 = x * math.log(y)
if abs(x1 - y1) < 1e-11:
	print('=')
elif x1 - y1 < 0:
	print('<')
elif y1 - x1 < 0:
	print('>')


from sys import stdin, stdout
from math import log10
from decimal import Decimal
(a, b) = map(Decimal, stdin.readline().split())
(a, b) = (b * Decimal(log10(a)), a * Decimal(log10(b)))
if a > b:
	stdout.write('>')
elif a < b:
	stdout.write('<')
else:
	stdout.write('=')


import sys
import math
import random
import time
from decimal import *
line = lambda : list((int(x) for x in input().split()))
MOD = int(1000000000.0 + 7)

def solve():
	(x, y) = line()
	fx = math.log(x) / x
	fy = math.log(y) / y
	if fx > fy:
		print('>')
	elif fx < fy:
		print('<')
	else:
		print('=')
st = time.time()
solve()
exit(0)


from math import log2
(x, y) = map(int, input().split())
a = y * log2(x)
b = x * log2(y)
if a < b:
	print('<')
elif a > b:
	print('>')
else:
	print('=')


(n, m) = map(int, input().strip().split())
if min(n, m) >= 3:
	if n > m:
		print('<')
	elif n == m:
		print('=')
	else:
		print('>')
elif min(n, m) == 1:
	if n == m:
		print('=')
	elif n == 1:
		print('<')
	else:
		print('>')
elif n == m:
	print('=')
else:
	e = 0
	if max(n, m) == 3:
		e = 1
	elif max(n, m) == 4:
		e = 2
	else:
		e = 3
	if e == 1:
		if n == 2:
			print('<')
		else:
			print('>')
	elif e == 2:
		print('=')
	elif n == 2:
		print('>')
	else:
		print('<')


import math
(a, b) = input().split()
(x, y) = (int(a), int(b))
res = y * math.log(x) - x * math.log(y)
if x == y:
	print('=')
elif res > 0:
	print('>')
elif res == 0:
	print('=')
else:
	print('<')


import math
(a, b) = input().split()
a = int(a)
b = int(b)
print('>' if b * math.log(a, 2) > a * math.log(b, 2) else '=' if b * math.log(a, 2) == a * math.log(b, 2) else '<')


import math
(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x > 2.4 and y > 2.4:
	if x > y:
		print('<')
	elif x < y:
		print('>')
	else:
		print('=')
else:
	first = x * math.log(y)
	second = y * math.log(x)
	if first > second:
		print('<')
	elif first < second:
		print('>')
	else:
		print('=')


import math
(a, b) = map(int, input().split())
aa = b * math.log(a)
bb = a * math.log(b)
if aa > bb:
	print('>')
elif aa < bb:
	print('<')
else:
	print('=')


(x, y) = input().split(' ')
x = int(x)
y = int(y)
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x <= 4 and y <= 4:
	a = x
	x = x ** y
	y = y ** a
	if x > y:
		print('>')
	elif x < y:
		print('<')
	else:
		print('=')
elif x < y:
	print('>')
elif x > y:
	print('<')


import math
(a, b) = map(int, input().split())
a1 = b * math.log(a)
b1 = a * math.log(b)
if abs(a1 - b1) < 1e-08:
	print('=')
elif a1 < b1:
	print('<')
else:
	print('>')


import math
(a, b) = map(int, input().split())
x = math.log(a) * b - math.log(b) * a
if x == 0:
	print('=')
elif x > 0:
	print('>')
else:
	print('<')


def main():
	(x, y) = map(int, input().split())
	if x > 2 and y > 2:
		if x > y:
			print('<')
		elif y > x:
			print('>')
		else:
			print('=')
	elif x == 2 and y > 4:
		print('>')
	elif y == 2 and x > 4:
		print('<')
	else:
		a = pow(x, y)
		b = pow(y, x)
		if a > b:
			print('>')
		elif b > a:
			print('<')
		else:
			print('=')
main()


s = input().split()
(x, y) = (int(s[0]), int(s[1]))
if x == y or (x == 2 and y == 4) or (x == 4 and y == 2):
	print('=')
elif x == 2 and y == 3 or x == 1:
	print('<')
elif x == 3 and y == 2 or y == 1:
	print('>')
elif x < y:
	print('>')
elif x > y:
	print('<')


import math
(n, m) = input().split()
n = float(n)
m = float(m)
a = math.log(n) / n
b = math.log(m) / m
if a == b:
	print('=')
elif a > b:
	print('>')
else:
	print('<')


import math
import sys
(x, y) = map(int, input().split())
if x == y:
	print('=')
	sys.exit(0)
else:
	a = y * math.log(x)
	b = x * math.log(y)
	if a > b:
		print('>')
	elif a < b:
		print('<')
	else:
		print('=')


import math
(x, y) = list(map(int, input().split()))
d1 = x * math.log(y)
d2 = y * math.log(x)
if d1 > d2:
	print('<')
elif d2 > d1:
	print('>')
else:
	print('=')


import math
(x, y) = map(int, input().split())
xy = x * math.log(y)
yx = y * math.log(x)
if abs(xy - yx) < 1e-08:
	print('=')
elif xy > yx:
	print('<')
else:
	print('>')


import math
(x, y) = map(int, input().split())
result1 = y * math.log2(x)
result2 = x * math.log2(y)
if result1 > result2:
	print('>')
elif result1 < result2:
	print('<')
else:
	print('=')


[x, y] = map(int, input().strip().split())

def solve(x, y):
	if x == y:
		return 0
	if x > y:
		return -solve(y, x)
	if x == 1:
		return -1
	if x == 2:
		if y == 3:
			return -1
		if y == 4:
			return 0
		return 1
	return 1
rs = '<=>'
print(rs[solve(x, y) + 1])


from sys import stdin, stdout
from math import *
(x, y) = map(int, input().split())
z = y * log(x) - x * log(y)
if z > 0:
	print('>')
elif z < 0:
	print('<')
else:
	print('=')


(a, b) = input().split()
x = int(a)
y = int(b)
from math import *
fs = y * log(x)
sc = x * log(y)
if fs == sc:
	print('=')
if fs > sc:
	print('>')
if fs < sc:
	print('<')


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

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

def map_string():
	return input().split()
(x, y) = map_input()
if x <= 5 and y <= 5 or x == 1 or y == 1:
	if x ** y > y ** x:
		print('>')
	elif x ** y == y ** x:
		print('=')
	else:
		print('<')
elif x < y:
	print('>')
elif x == y:
	print('=')
else:
	print('<')


import math
(x, y) = input().strip().split(' ')
(x, y) = [int(x), int(y)]
a = math.log(x) / x
b = math.log(y) / y
if a > b:
	print('>')
elif a < b:
	print('<')
else:
	print('=')


from math import *
(a, b) = map(int, input().split())
if a == b:
	print('=')
elif a == 2 and b == 4 or (a == 4 and b == 2):
	print('=')
elif round(b * log(a), 5) > round(a * log(b), 5):
	print('>')
else:
	print('<')


from math import log
s = input().split()
(x, y) = (float(s[0]), float(s[1]))
(a, b) = (y * log(x), x * log(y))
if a > b:
	print('>')
elif a < b:
	print('<')
else:
	print('=')


import sys
inf = float('inf')
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(x, y) = get_ints()
if x == y:
	print('=')
	exit(0)
a1 = y * log(x)
a2 = x * log(y)
if a1 < a2:
	print('<')
elif a1 > a2:
	print('>')
else:
	print('=')


(a, b) = map(int, input().split())
import math
s1 = b * math.log(a)
s2 = a * math.log(b)
if s1 < s2:
	print('<')
elif s1 > s2:
	print('>')
else:
	print('=')


(a, b) = [int(x) for x in input().split()]
c = 0
if a > b:
	c = 1
	(a, b) = (b, a)
if a > pow(b, a / b):
	print('>' if not c else '<')
elif a < pow(b, a / b):
	print('<' if not c else '>')
else:
	print('=')


from math import log
(x, y) = map(int, input().split())
if x == 1 and y == 1:
	print('=')
	exit()
elif x == 1:
	print('<')
	exit()
elif y == 1:
	print('>')
	exit()
xy = y
yx = x * log(y, x)
if xy == yx:
	print('=')
elif xy > yx:
	print('>')
else:
	print('<')


from math import log
(x, y) = map(int, input().split())
if x > y:
	if y == 1:
		print('>')
	else:
		z = log(x, y)
		if x == y * z:
			print('=')
		elif max(x, y) > 3:
			print('<')
		else:
			print('>')
elif y > x:
	if x == 1:
		print('<')
	else:
		z = log(y, x)
		if y == x * z:
			print('=')
		elif max(x, y) > 3:
			print('>')
		else:
			print('<')
else:
	print('=')


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if val % ll[mid] == 0:
			ans = ll[mid]
			return binary(l, mid - 1, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def odd(n, ans, s):
	if n % 2 != 0 or n in s:
		return ans
	else:
		s.add(n)
		return odd(n // 2, ans + 1, s)
(a, b) = map(int, input().split(' '))
if a == b:
	print('=')
elif a == 1:
	print('<')
elif b == 1:
	print('>')
elif a == 2:
	if b == 3:
		print('<')
	elif b == 4:
		print('=')
	else:
		print('>')
elif b == 2:
	if a == 3:
		print('>')
	elif a == 4:
		print('=')
	else:
		print('<')
elif a > b:
	print('<')
elif a < b:
	print('>')


import math
(x, y) = map(int, input().split())
f = y * math.log10(x)
s = x * math.log10(y)
if f > s:
	print('>')
elif f < s:
	print('<')
else:
	print('=')


import math
f = input().split(' ')
x = int(f[0])
y = int(f[1])
xx = math.log(x) / x
yy = math.log(y) / y
if xx > yy:
	print('>')
elif xx < yy:
	print('<')
else:
	print('=')


yoar = list(map(int, input().split()))
x = yoar[0]
y = yoar[1]
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x == 2 and y != 1:
	if y >= 5:
		print('>')
	elif y == 4:
		print('=')
	else:
		print('<')
elif y == 2 and x != 1:
	if x >= 5:
		print('<')
	elif x == 4:
		print('=')
	else:
		print('>')
elif x < y:
	print('>')
else:
	print('<')


import math
(x, y) = (int(x) for x in input().split())
newX = y * math.log(x, 10)
newY = x * math.log(y, 10)
if newX > newY:
	print('>')
elif newX < newY:
	print('<')
else:
	print('=')


from math import log
from random import randint
(x, y) = list(map(int, input().split()))

def solve(x, y):
	if x == y:
		print('=')
	else:
		lx = log(x)
		ly = log(y)
		if lx / x > ly / y:
			print('>')
		elif lx / x == ly / y:
			print('=')
		else:
			print('<')
solve(x, y)


import math
(x, y) = map(int, input().split())
v1 = y * math.log(x, 10)
v2 = x * math.log(y, 10)
if v1 < v2:
	print('<')
elif v1 > v2:
	print('>')
else:
	print('=')


import math
a = list(input().split())
x = int(a[0])
y = int(a[1])
if x == y:
	print('=')
elif x > 1 and y > 1:
	if math.log(x) / math.log(y) > x / y:
		print('>')
	elif math.log(x) / math.log(y) < x / y:
		print('<')
	else:
		print('=')
elif x > y:
	print('>')
else:
	print('<')


import math
(a, b) = map(int, input().split())
sum1 = b * math.log(a)
sum2 = a * math.log(b)
if sum1 > sum2:
	print('>')
elif sum1 < sum2:
	print('<')
else:
	print('=')


(x, y) = list(map(int, input().split()))
if x + y > 10:
	if x == 1 or y == 1:
		pass
	else:
		(x, y) = (y, x)
else:
	(x, y) = (x ** y, y ** x)
if x == y:
	print('=')
elif x > y:
	print('>')
else:
	print('<')


import sys, math
line = sys.stdin.readline()
nums = line.replace('\n', '').split(' ')
x = int(nums[0])
y = int(nums[1])
if x == y or math.fabs(y * math.log2(x) - x * math.log2(y)) < 1e-21:
	print('=')
elif y * math.log2(x) < x * math.log2(y):
	print('<')
else:
	print('>')


(a, b) = map(int, input().split())
if a == 1 and b != 1:
	print('<')
	exit(0)
if b == 1 and a != 1:
	print('>')
	exit(0)
if max(a, b) < 12:
	if a ** b > b ** a:
		print('>')
	elif a ** b < b ** a:
		print('<')
	else:
		print('=')
elif a < b:
	print('>')
elif a > b:
	print('<')
else:
	print('=')


a = [int(i) for i in input().split()]
x = a[0]
y = a[1]
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x == 2 and y == 3:
	print('<')
elif x == 2 and y == 4:
	print('=')
elif x == 2:
	print('>')
elif y == 2 and x == 3:
	print('>')
elif y == 2 and x == 4:
	print('=')
elif y == 2:
	print('<')
elif x >= 3 and y >= 3:
	if x > y:
		print('<')
	else:
		print('>')


from math import log
(x, y) = [int(i) for i in input().split()]
left = y * log(x)
right = x * log(y)
if left < right:
	print('<')
elif left > right:
	print('>')
else:
	print('=')


import math
(a, b) = map(int, input().split())
k = b * math.log(a)
p = a * math.log(b)
if k > p:
	print('>')
elif p > k:
	print('<')
else:
	print('=')


from math import *
(x, y) = map(int, input().split())

def g(x, y):
	X = y * log(x)
	Y = x * log(y)
	if abs(X - Y) < 1e-09:
		print('=')
	elif X > Y:
		print('>')
	else:
		print('<')
g(x, y)


n = list(map(int, input().split()))
if n[0] == n[1]:
	print('=')
elif n[0] > 2.7 and n[1] > 2.7:
	if n[1] > n[0]:
		print('>')
	else:
		print('<')
elif n[0] < 2.7 and n[1] < 2.7:
	if n[1] > n[0]:
		print('<')
	else:
		print('>')
elif n[0] == 1:
	print('<')
elif n[1] == 1:
	print('>')
elif n[0] == 2:
	if n[1] < 4:
		print('<')
	elif n[1] == 4:
		print('=')
	else:
		print('>')
elif n[1] == 2:
	if n[0] < 4:
		print('>')
	elif n[0] == 4:
		print('=')
	else:
		print('<')


import math
(a, b) = map(int, input().split())
first = b * math.log(a)
second = a * math.log(b)
if first > second:
	print('>')
elif first < second:
	print('<')
else:
	print('=')


import math
x = [int(num) for num in input().split()]
p = x[1] * math.log(x[0])
q = x[0] * math.log(x[1])
if p > q:
	print('>')
elif p < q:
	print('<')
else:
	print('=')


import math
(x, y) = list(map(int, input().split()))
a1 = math.log(x) * y
a2 = math.log(y) * x
if abs(a1 - a2) < 1e-10:
	print('=')
elif a1 < a2:
	print('<')
else:
	print('>')


import decimal
decimal.MAX_EMAX = 10 ** 10
decimal.getcontext().Emax = 10 ** 10
(x, y) = [decimal.Decimal(el) for el in input().split()]
power = decimal.getcontext().power
xy = power(x, y)
yx = power(y, x)
if xy > yx:
	print('>')
elif xy < yx:
	print('<')
else:
	print('=')


import sys
sys.setrecursionlimit(2000)
from collections import Counter
from math import log
(x, y) = [int(val) for val in input().split()]
if x > 3 and y > 3:
	if x < y:
		ans = '>'
	elif x > y:
		ans = '<'
	else:
		ans = '='
else:
	val1 = log(x) / x
	val2 = log(y) / y
	if val1 > val2:
		ans = '>'
	elif val1 < val2:
		ans = '<'
	else:
		ans = '='
print(ans)


import math
(n, m) = [int(x) for x in input().split()]
a = m * math.log(n)
b = n * math.log(m)
if a == b:
	print('=')
elif a > b:
	print('>')
else:
	print('<')


params = list(map(int, list(input().split())))
(x, y) = (params[0], params[1])
if x == y:
	print('=')
elif x == 1:
	print('<')
elif y == 1:
	print('>')
elif x + y == 6:
	print('=')
elif x + y < 6:
	if x ** y < y ** x:
		print('<')
	else:
		print('>')
elif x > y:
	print('<')
else:
	print('>')


(n, m) = map(int, input().split())
if n == 1:
	if m == 1:
		print('=')
	else:
		print('<')
elif m == 1:
	if n == 1:
		print('=')
	else:
		print('>')
elif max(n, m) < 7:
	a = n ** m
	b = m ** n
	if a < b:
		print('<')
	elif a > b:
		print('>')
	else:
		print('=')
elif m < n:
	print('<')
elif m > n:
	print('>')
else:
	print('=')


from math import log10 as l10
(x, y) = map(int, input().split())
c = x * l10(y) - y * l10(x)
if c > 0:
	print('<')
elif c < 0:
	print('>')
else:
	print('=')


import math
line = list(map(int, input().split()))
m = line[0]
n = line[1]
p = n * math.log10(m)
q = m * math.log10(n)
if p > q:
	print('>')
elif p < q:
	print('<')
else:
	print('=')


import math
values = input()
(x, y) = values.split()
x = int(x)
y = int(y)
respA = y * math.log(x, 2)
respB = x * math.log(y, 2)
if respA > respB:
	print('>')
elif respB > respA:
	print('<')
else:
	print('=')


import math
(x, y) = map(int, input().split())
if x == 1 or y == 1:
	if x ** y == y ** x:
		print('=')
	elif x ** y > y ** x:
		print('>')
	else:
		print('<')
	exit()
(x, y) = (y, x * math.log(y, x))
if x == y:
	print('=')
elif x > y:
	print('>')
else:
	print('<')


import sys
(xx, yy) = input().split()
(xx, yy) = (int(xx), int(yy))
y = max(xx, yy)
x = min(xx, yy)
t = y / x
if t == 1:
	print('=')
	sys.exit(0)
u = t ** (1 / (t - 1))
uff = 0
if x > u:
	li = [x, y]
	uff = 1
if x < u:
	li = [y, x]
	uff = 1
if uff == 1:
	if xx == li[0]:
		print('>')
if uff == 1:
	if xx == li[1]:
		print('<')
else:
	print('=')


from math import log
(x, y) = map(float, input().split())
(a, b) = (y * log(x), x * log(y))
if a > b:
	print('>')
elif a < b:
	print('<')
else:
	print('=')


from math import log

def sol(a, b):
	log_apowb = b * log(a)
	log_bpowa = a * log(b)
	if log_apowb > log_bpowa:
		print('>')
	elif log_apowb < log_bpowa:
		print('<')
	else:
		print('=')
(a, b) = map(int, input().split(' '))
if a == 0 and b != 0:
	print('<')
elif b == 0 and a != 0:
	print('>')
elif a == 0 and b == 0:
	print('=')
elif a == 1 and b != 1:
	print('<')
elif b == 1 and a != 1:
	print('>')
elif b == 1 and a == 1:
	print('=')
else:
	sol(a, b)


import math
a = list(map(int, input().strip().split()))
x = a[0]
y = a[1]

def check():
	if x == 1 and y == 1:
		print('=')
		return
	if y * math.log(x) > x * math.log(y):
		print('>')
		return
	elif y * math.log(x) < x * math.log(y):
		print('<')
		return
	else:
		print('=')
		return
check()


import math
(a, b) = map(int, input().split())
if a == 1 or b == 1:
	if a == 1 and b == 1:
		print('=')
	elif a < b:
		print('<')
	else:
		print('>')
else:
	x = math.log(b, a)
	n = b / x
	if n > a:
		print('>')
	elif n == a:
		print('=')
	else:
		print('<')


(x, y) = [int(z) for z in input().split()]
if x == 1:
	if y == 1:
		print('=')
	else:
		print('<')
elif y == 1:
	print('>')
elif x == 2:
	if y == 2 or y == 4:
		print('=')
	elif y == 3:
		print('<')
	else:
		print('>')
elif y == 2:
	if x == 4:
		print('=')
	elif x == 3:
		print('>')
	else:
		print('<')
elif x == y:
	print('=')
elif x < y:
	print('>')
else:
	print('<')


import math, sys
(x, y) = map(int, input().split())
if y == 1:
	if x == 1:
		print('=')
	else:
		print('>')
	sys.exit()
ans = y * math.log(x, y) / x
if ans > 1:
	print('>')
elif ans == 1:
	print('=')
else:
	print('<')


import sys, math, os.path

def log(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def ni():
	return map(int, input().split(' '))

def nio(offset):
	return map(lambda x: int(x) + offset, input().split(' '))

def nia():
	return list(map(int, input().split()))
(x, y) = ni()

def solve():
	if x == y:
		return '='
	if x == 1:
		return '<'
	if y == 1:
		return '>'
	if x == 2 and y == 3:
		return '<'
	if x == 2 and y == 4:
		return '='
	if x == 3 and y == 2:
		return '>'
	if x == 4 and y == 2:
		return '='
	if x < y:
		return '>'
	if x > y:
		return '<'
print(solve())


import math
n = list(map(int, input().split()))
x = n[1] * math.log(n[0])
y = n[0] * math.log(n[1])
if x > y:
	print('>')
if x < y:
	print('<')
if x == y:
	print('=')


import math
t = input()
(x, y) = t.split(' ')
x = float(x)
y = float(y)
a = x * math.log(y)
b = y * math.log(x)
if a == b:
	print('=')
elif a < b:
	print('>')
else:
	print('<')


(x, y) = (int(x) for x in input().split())
if x == y:
	print('=')
elif x == 1 or y == 1:
	print('<' if x == 1 else '>')
elif x > 5 or y > 5:
	if x == y:
		print('=')
	elif y < x:
		print('<')
	else:
		print('>')
else:
	xy = x ** y
	yx = y ** x
	if xy == yx:
		print('=')
	elif xy < yx:
		print('<')
	else:
		print('>')


from math import log10
(x, y) = map(int, input().split(' '))
logx = log10(x)
logy = log10(y)
if y * logx > x * logy:
	print('>')
elif y * logx < x * logy:
	print('<')
else:
	print('=')


import math
(x, y) = map(int, input().split())
res1 = math.log(x, 2) * y
res2 = math.log(y, 2) * x
if res1 == res2:
	print('=')
elif res1 < res2:
	print('<')
else:
	print('>')


def cmp(x, y):
	if x == y:
		return '='
	if x == 1:
		return '<'
	if y == 1:
		return '>'
	if x == 2:
		if y == 3:
			return '<'
		if y == 4:
			return '='
	if y == 2:
		if x == 3:
			return '>'
		if x == 4:
			return '='
	return '>' if x < y else '<'
(x, y) = [int(f) for f in input().split()]
print(cmp(x, y))


import math as mm
(x, y) = map(int, input().split(' '))
a = y * mm.log(x)
b = x * mm.log(y)
if a > b:
	print('>')
elif b > a:
	print('<')
else:
	print('=')


import math
temp = input().split(' ')
x = int(temp[0])
y = int(temp[1])
if y * math.log10(x) > x * math.log10(y):
	print('>')
elif y * math.log10(x) < x * math.log10(y):
	print('<')
else:
	print('=')


def solve(a, b):
	if a == b:
		return '='
	elif a > b:
		(a, b) = (b, a)
		bol = 1
	else:
		bol = 0
	if a == 1 or (a == 2 and b < 4):
		bol1 = 0
	elif (a, b) == (2, 4):
		return '='
	else:
		bol1 = 1
	if bol == bol1:
		return '<'
	else:
		return '>'
(a, b) = map(int, input().split())
print(solve(a, b))


from math import log
(x, y) = map(int, input().split())
x *= 1.0
y *= 1.0
if abs(pow(x, y / 100000000.0) - pow(y, x / 100000000.0)) < 1e-09:
	print('=')
elif pow(x, y / 100000000.0) > pow(y, x / 100000000.0):
	print('>')
else:
	print('<')


cnt = lambda s, x: s.count(x)
ii = lambda : int(input())
si = lambda : input()
f = lambda : map(int, input().split())
dgl = lambda : list(map(int, input()))
il = lambda : list(map(int, input().split()))
(x, y) = f()
if 0 < x <= 10 and 0 < y <= 10:
	if x ** y > y ** x:
		print('>')
	else:
		print(['<', '='][x ** y == y ** x])
elif x == 1 or y == 1:
	if x ** y > y ** x:
		print('>')
	else:
		print(['<', '='][x ** y == y ** x])
elif x < y:
	print('>')
else:
	print(['<', '='][x == y])


(n, m) = map(int, input().split())
pow_1 = m
pow_2 = n
while pow_1 > 1 or pow_2 > 1:
	pow_1 /= 2
	pow_2 /= 2
if n == m:
	print('=')
else:
	n = pow(n, pow_1)
	m = pow(m, pow_2)
	if n > m:
		print('>')
	elif n < m:
		print('<')
	else:
		print('=')


def main():
	(x, y) = map(int, input().split())
	if x == y:
		print('=')
		return
	if x == 1 and y != 1:
		print('<')
	elif y == 1 and x != 1:
		print('>')
	elif x < 1000 and y < 1000:
		if x ** y > y ** x:
			print('>')
		elif x ** y < y ** x:
			print('<')
		else:
			print('=')
	elif x > y:
		print('<')
	elif y > x:
		print('>')
	else:
		print('=')
main()


from math import log
(x, z) = map(int, input().split())
a = x * log(z)
b = z * log(x)
if a == b:
	print('=')
elif a < b:
	print('>')
else:
	print('<')


(x, y) = list(map(int, input().split()))
from math import log
if y != 1:
	t = y * log(x, y)
	if x == t or x == y:
		print('=')
	elif x < t:
		print('>')
	else:
		print('<')
elif x == 1:
	print('=')
else:
	print('>')


a = list(map(int, input().split(' ')))
if a[0] == a[1]:
	print('=')
	exit()
if a[1] == 1:
	print('>')
	exit()
if a[0] == 1:
	print('<')
	exit()
if a[0] > 2 and a[1] > 2:
	if a[0] > a[1]:
		print('<')
	if a[0] == a[1]:
		print('=')
	if a[0] < a[1]:
		print('>')
	exit()
elif a[0] > 2 and a[1] == 2:
	if a[0] == 4:
		print('=')
	elif a[0] == 3:
		print('>')
	else:
		print('<')
if a[0] == 2:
	if a[1] == 3:
		print('<')
		exit()
	if a[1] == 4:
		print('=')
	else:
		print('>')


def f(n):
	return n ** (1 / n)
e = 3
(a, b) = map(int, input().split())
if a == b:
	print('=')
else:
	A = max(a, b)
	B = min(a, b)
	if B >= 3:
		if a > b:
			print('<')
		else:
			print('>')
	elif A <= 3:
		if a > b:
			print('>')
		else:
			print('<')
	else:
		if B == 1:
			if a > b:
				print('>')
			else:
				print('<')
		if B == 2:
			if A == 4:
				print('=')
			elif a > b:
				print('<')
			else:
				print('>')


import configparser
import math
import sys
input = sys.stdin.readline

def main():
	(n, m) = [int(x) for x in input().split(' ')]
	second = n * math.log(m, 2)
	first = m * math.log(n, 2)
	if n == m or (n, m) == (2, 4) or (n, m) == (4, 2):
		print('=')
		return
	if first > second:
		print('>')
	else:
		print('<')
main()


(x, y) = map(int, input().split())
if x == y:
	print('=')
elif x > y:
	if y > x ** (y / x):
		print('<')
	elif y < x ** (y / x):
		print('>')
	else:
		print('=')
elif x > y ** (x / y):
	print('>')
elif x < y ** (x / y):
	print('<')
else:
	print('=')


import math
(n, m) = map(int, input().split(' '))
(s1, s2) = (0, 0)
s1 = math.log(m) * n
s2 = math.log(n) * m
print('<' if s1 > s2 else '>' if s2 > s1 else '=')


import math as m
(n, k) = map(int, input().split())
if n * m.log2(k) > k * m.log2(n):
	print('<')
elif n * m.log2(k) < k * m.log2(n):
	print('>')
else:
	print('=')


import math
(x, y) = input().split()
s1 = math.log(int(x)) * int(y)
s2 = math.log(int(y)) * int(x)
if x == y:
	print('=')
elif s1 > s2:
	print('>')
elif s1 < s2:
	print('<')
else:
	print('=')


import math
(x, y) = list(map(int, input().split(' ')))
k = y * math.log10(x)
l = x * math.log10(y)
if k > l:
	print('>')
elif k < l:
	print('<')
else:
	print('=')


from decimal import *
from sys import exit
getcontext().prec = 50
(x, y) = input().split()
if x == y:
	print('=')
	exit(0)
dx = Decimal(x)
dy = Decimal(y)
if '1' in (x, y):
	if x == '1':
		print('<')
	else:
		print('>')
	exit(0)
dx = dx * (dy.ln() / dx.ln())
if dy < dx:
	print('<')
elif dy > dx:
	print('>')
else:
	print('=')


import math
(x, y) = map(int, input().split())
if min(x, y) == 1:
	if x > y:
		t = 1.1
	elif x == y:
		t = 1
	else:
		t = 0.9
else:
	t = y / x * (math.log10(x) / math.log10(y))
if t < 1:
	print('<')
elif t == 1:
	print('=')
else:
	print('>')


import math
t = list(map(int, input().split()))
if t[0] * math.log(t[1]) == t[1] * math.log(t[0]):
	print('=')
elif t[0] * math.log(t[1]) > t[1] * math.log(t[0]):
	print('<')
elif t[0] * math.log(t[1]) < t[1] * math.log(t[0]):
	print('>')


(x, y) = map(int, input().split())
if x < 3 or y < 3:
	if x ** y < y ** x:
		print('<')
	elif x ** y == y ** x:
		print('=')
	else:
		print('>')
elif x < y:
	print('>')
elif x > y:
	print('<')
else:
	print('=')


(x, y) = map(int, input().split())
(l, g) = '<>'
if x > y:
	(x, y, l, g) = (y, x, g, l)
c = g
if x == y or (x, y) == (2, 4):
	c = '='
elif x == 1 or (x, y) == (2, 3):
	c = l
print(c)


import math
(x, y) = list(map(int, input().split()))
if x == 1 or y == 1:
	if x ** y == y ** x:
		print('=')
	elif x ** y > y ** x:
		print('>')
	else:
		print('<')
	return
(x, y) = (y, x * math.log(y, x))
if x == y:
	print('=')
elif x > y:
	print('>')
else:
	print('<')


from math import log as l
(a, b) = map(int, input().split())
x = b * l(a) - a * l(b)
if abs(x) < 1e-10:
	x = 0
print('>' if x > 0 else '<' if x < 0 else '=')


from math import log
entrada = input()
entrada_float = list(map(float, entrada.split(' ')))
a = entrada_float[0]
b = entrada_float[1]
x = b * log(a, 10)
y = a * log(b, 10)
if x == y:
	print('=')
elif x < y:
	print('<')
else:
	print('>')


import math
x = input().split(' ')
a = int(x[0])
b = int(x[1])
aa = math.log(a) / a
bb = math.log(b) / b
if aa > bb:
	print('>')
elif aa < bb:
	print('<')
else:
	print('=')


(a, b) = map(int, input().split())
if a == b or (a == 2 and b == 4) or (a == 4 and b == 2):
	print('=')
elif a == 1 or (a == 2 and b == 3):
	print('<')
elif b == 1 or (a == 3 and b == 2):
	print('>')
elif a > b:
	print('<')
elif a < b:
	print('>')


from math import *
(x, y) = map(int, input().split())
X = log(x, 2) * y
Y = log(y, 2) * x
if X == Y:
	print('=')
elif X > Y:
	print('>')
else:
	print('<')


def tavan(a, b):
	if b == 0:
		return 1
	cnt = 1
	if b % 2 == 1:
		cnt = a
	return tavan(a * a, b // 2) * cnt

def inp():
	return list(map(int, input().split(' ')))
(a, b) = inp()
if a == b:
	print('=')
elif a == 1 or b == 1:
	if a == 1:
		print('<')
	else:
		print('>')
elif min(a, b) < 100 and max(a, b) > 1000:
	if a < b:
		print('>')
	else:
		print('<')
elif a >= 100 and b >= 100:
	if a < b:
		print('>')
	else:
		print('<')
elif tavan(a, b) > tavan(b, a):
	print('>')
elif tavan(a, b) < tavan(b, a):
	print('<')
else:
	print('=')


from sys import *
from math import *
from bisect import *
(a, b) = map(int, stdin.readline().split())
x = b * log(a)
y = a * log(b)
if x > y:
	print('>')
elif x < y:
	print('<')
else:
	print('=')


import math
(x, y) = (int(q) for q in input().split())
(log_x, log_y) = (math.log2(x), math.log2(y))
if y * log_x > x * log_y:
	print('>')
elif y * log_x == x * log_y:
	print('=')
elif y * log_x < x * log_y:
	print('<')


import math
import logging
fmt = '%(levelname)s - %(name)s (line:%(lineno)s) - %(message)s'
formatter = logging.Formatter(fmt)
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)
logger = logging.getLogger('high_school_become_human')
logger.setLevel(logging.ERROR)
logger.addHandler(ch)

def solve(x, y):
	if x * math.log(y) == y * math.log(x):
		return '='
	return '>' if y * math.log(x) > x * math.log(y) else '<'

def main():
	(x, y) = map(int, input().strip().split())
	result = solve(x, y)
	print(result)
main()


import math
entrada = input().split()
x = int(entrada[0])
y = int(entrada[1])
n = 0
m = 0
i = 0
j = 0
k = 0
if x == y:
	print('=')
else:
	a = y * math.log10(x)
	b = x * math.log10(y)
	if a == b:
		print('=')
	elif a > b:
		print('>')
	else:
		print('<')


import time
import math
start = time.time()
(x, y) = map(int, input().split(' '))
a = y * math.log(x, 10)
b = x * math.log(y, 10)
if a > b:
	print('>')
elif a < b:
	print('<')
else:
	print('=')
end = time.time()


from math import log
(a, b) = [int(x) for x in input().split()]
if a == b == 1:
	print('=')
	exit()
if a == 1:
	print('<')
	exit()
if b == 1:
	print('>')
	exit()
ratio = log(b, a)
if b == ratio * a:
	print('=')
elif b > ratio * a:
	print('>')
else:
	print('<')


from math import log10
xy = list(map(int, input().split()))
x = xy[0]
y = xy[1]
xlog = y * log10(x)
ylog = x * log10(y)
if xlog > ylog:
	print('>')
elif xlog < ylog:
	print('<')
else:
	print('=')


from copy import deepcopy
import itertools
from bisect import bisect_left
import math

def read():
	return int(input())

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

def readlist():
	return list(map(int, input().split()))
(x, y) = readmap()
if y * math.log(x) < x * math.log(y):
	print('<')
elif y * math.log(x) > x * math.log(y):
	print('>')
else:
	print('=')