Problem:
 Score : 100 points    Problem Statement There are two rectangles.
The lengths of the vertical sides of the first rectangle are A , and the lengths of the horizontal sides of the first rectangle are B .
The lengths of the vertical sides of the second rectangle are C , and the lengths of the horizontal sides of the second rectangle are D .  Print the area of the rectangle with the larger area.
If the two rectangles have equal areas, print that area.      Constraints  All input values are integers.  1≤A≤10^4  1≤B≤10^4  1≤C≤10^4  1≤D≤10^4         Input The input is given from Standard Input in the following format:  A  B  C  D       Output Print the area of the rectangle with the larger area.
If the two rectangles have equal areas, print that area.        Sample Input 1 3 5 2 7      Sample Output 1 15  The first rectangle has an area of 3×5=15 , and the second rectangle has an area of 2×7=14 .
Thus, the output should be 15 , the larger area.       Sample Input 2 100 600 200 300      Sample Output 2 60000

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)


def main():
	a,b,c,d = map(int,input().split())
	print(max(a*b,c*d))
	

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(l):
	x = l.pop()
	y = l.pop()
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	l.append(min(x,y))
	return gcd(l) if len(l) > 1 else l[0]

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

Solution (Python):
a, b, c, d = map(int, input().split())
print(a*b) if a*b>c*d else print(c*d)

Solution (Python):
a, b, c, d = [int(i) for i in input().split()]

if a * b > c * d :
    print(a * b)
else:
    print(c * d)

Solution (Python):
A,B,C,D=map(int,input().split())

print(max(A*B,C*D))

Solution (Python):
a,b,c,d = map(int,input().split())
if a*b >= c*d:
  print(a*b)
else:
  print(c*d)

Solution (Python):
A,B,C,D=[int(x) for x in input().split()]
print(max(A*B,C*D))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
n = list(map(int, input().split()))
print(max(n[0]*n[1], n[2]*n[3]))

Solution (Python):
l = list(map(int,input().split()))
if l[0]*l[1] >= l[2]*l[3]:
  print(l[0]*l[1])
else:
  print(l[2]*l[3])

Solution (Python):




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



if a * b >= c * d:
  print(a * b)
else:
  print(c * d)

Solution (Python):
a,b,c,d = map(int,input().split())
if a*b > c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):

from collections import defaultdict
import sys

def soinsuu(soinsuu_dic, num):
    for i in range(2, int(num ** 0.5) + 1):
        while num % i == 0:
            num //= i
            soinsuu_dic[i] += 1
    if num > 1:
        soinsuu_dic[num] += 1
    return soinsuu_dic

def main():
    a, b, c, d = map(int, input().split())
    print(max(a * b, c * d))




if __name__ == '__main__':
    main()

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
a, b, c, d = map(int, input().split())
if a * b >= c * d:
  print(a * b)
else:
  print(c * d)

Solution (Python):
a,b,c,d = map(int,input().split())

if a*b >= c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A,B,C,D = list(map(int,input().split()))
print(max(A*B,C*D))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
if a*b>=c*d:
  print(a*b)
else:
  print(c*d)

Solution (Python):
def larger(x, y):
	if x > y:
		return x
	return y

A, B, C, D = map(int, input().split())
print(larger(A*B, C*D))

Solution (Python):
s = input()
s = s.split(" ")
nums = list(map(int,s))

first = nums[0] * nums[1]
second = nums[2] * nums[3]

print(first if first >= second else second)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
a, b, c, d = map(int, input().split())
ans = max(a*b, c*d)
print(ans)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b, c*d))

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a, b, c, d = MAP()
print(max(a * b , c * d))

Solution (Python):
a, b, c, d = map(int, input().split())

print(max(a*b, c*d))

Solution (Python):
A,B,C,D = list(map(int,input().split()))

if A * B >= C * D :
    print(A * B)
elif A * B < C * D :
    print(C * D)

Solution (Python):
a,b,c,d = map(int, input().split())

if a*b <= c*d:
    print(c*d)
if a*b > c*d:
    print(a*b)

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())
print(a*b) if a*b > c*d else print(c*d)

Solution (Python):

import sys
sys.setrecursionlimit(300000)


def solve(A: int, B: int, C: int, D: int):
    ret = max(A * B, C * D)
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    D = int(next(tokens))  
    solve(A, B, C, D)

if __name__ == '__main__':
    main()

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
A,B,C,D = map(int, input().split())
ab_scale = A*B
cd_scale = C*D
if ab_scale > cd_scale:
  print(A*B)
else:
  print(C*D)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
z=list(map(int,input().split()))
print(max(z[0]*z[1],z[2]*z[3]))

Solution (Python):
import sys
lines = sys.stdin.readlines()
for linea in lines:
    c = linea.split()
    c = list(map(int,c))
list(c)
x = c[0]*c[1]
v =c[2]*c[3]
if x>v:
  print(x)
if x<v:
  print(v)
if x==v:
  print(x)

Solution (Python):
a,b,c,d=map(int,input().split())
area1=a*b
area2=c*d
if area1>area2:
  print(area1)
elif area1<area2:
  print(area2)
else:
  print(area1)

Solution (Python):
a,b,c,d = list(map(int, input().split()))
if(a*b >= c*d):
  print(a*b)
else:
  print(c*d)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max([a*b,c*d]))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a, b, c, d = LI()
    print(max(a * b, c * d))
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

Solution (Python):
a, b, c, d = map(int, input().split(" "))
print(max(a*b, c*d))

Solution (Python):
A, B, C, D = map(int, input().split())

print(max(A * B, C * D))

Solution (Python):
A,B,C,D = map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a,b,c,d = map(int, input().split())
if a*b > c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):

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

print ( max(A*B , C*D ))

Solution (Python):
def main():
    a,b,c,d=map(int,input().split(' '))
    print(max(a*b,c*d))
if __name__ == '__main__':
    main()

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
[A,B,C,D] = list(map(int,input().split()))
print(max(A*B,C*D))

Solution (Python):



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

print(max(a*b,c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
ab= a*b
cd= c*d
if ab==cd:print(ab)
else:print(max(ab,cd))

Solution (Python):
a, b, c, d = (int(x) for x in input().split())
print(max(a*b, c*d))

Solution (Python):



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


print(max(A * B, C * D))

Solution (Python):
a,b,c,d = map(int,input().split())

ab = a * b
cd = c * d

if ab >= cd:
    print(ab)
else:
    print(cd)

Solution (Python):
a, b, c, d = map(int, input().split())

if a * b > c * d:
    print(a * b)
else:
    print(c * d)

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())
x = a*b
y = c*d

if x<=y:
    print(y)
else:
    print(x)

Solution (Python):
a,b,c,d = map(int,input().split())
if a*b > c*d:
  print(a*b)
else:
  print(c*d)

Solution (Python):
A, B, C, D = map(int, input().split())
print(max(A*B, C*D))

Solution (Python):
A,B,C,D = map(int,input().split())
print(A*B if A*B>C*D else C*D)

Solution (Python):
a, b, c, d = map(int, input().split())
ab = a * b
cd = c * d
print(ab if ab > cd else cd)

Solution (Python):
A, B, C, D = map(int, input().split())

firstSquare = A * B
secondSquare = C * D

print(max(firstSquare, secondSquare))

Solution (Python):
a, b, c, d = list(map(int, input().split()))
print(max(a*b, c*d))

Solution (Python):
a, b, c, d = map(int, input().split())

f = a * b
s = c * d

if f >= s:
    print(f)
else:
    print(s)

Solution (Python):
A, B, C, D = map(int, input().split())

if A * B > C * D:
    print(A*B)
else:
    print(C*D)

Solution (Python):
A, B, C, D = map(int, input().split())
s1 = A * B
s2 = C * D

if s1 > s2:
    print(s1)
else:
    print(s2)

Solution (Python):
a,b,c,d = map(int,input().split())
x = a*b
y = c*d
if x>=y:
    print(x)
else:
    print(y)

Solution (Python):
A, B, C, D = map(int, input().split())
if(A*B >= C*D):
    print(A*B)
else:
    print(C*D)

Solution (Python):
A, B, C, D = map(int, input().split())

ab = A * B
cd = C * D

print(max(ab, cd))

Solution (Python):
a = list(map(int,input().split()))
b = a[0]*a[1]
c = a[2]*a[3]

if b > c:
  print(b)
else:
  print(c)

Solution (Python):
a,b,c,d = list(map(int, input().split()))
print(max(a*b,c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())
if a * b < c * d:
    print(c * d)
else:
    print(a * b)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max([a*b,c*d]))

Solution (Python):
A,B,C,D=map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
inp = input().split()
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])
d = int(inp[3])

if a*b >= c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int, input().split())

print(max([a*b,c*d]))

Solution (Python):
A, B, C, D = map(int, input().split())

s1 = A * B
s2 = C * D

if s1 <= s2:
  print(int(s2))
else:
  print(int(s1))

Solution (Python):
a, b, c, d =map(int, input().split())
print(max(a*b,c*d))

Solution (Python):
A, B, C, D = map(int, input().split())
print(str(max(A*B, C*D)))

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

A, B, C, D = nl()

if A*B > C*D:
    print(A*B)
else:
    print(C*D)

Solution (Python):
a, b, c, d = map(int, input().split())
if a * b >= c * d:
    print(a * b)
elif a * b < c * d:
    print(c*d)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
a, b, c, d = map(int, input().split())

one = a * b
two = c * d

print(max(one, two))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b, c*d))

Solution (Python):
first=input()
(A, B, C, D)=first.split()
A=int(A)
B=int(B)
C=int(C)
D=int(D)
answer1=A*B
answer2=C*D
if (A*B)>(C*D):
  print(answer1)
elif (A*B)<=(C*D):
  print(answer2)

Solution (Python):
sc = input()
(a,b,c,d) = sc.split()
x = int(a)*int(b)
y = int(c)*int(d)
if x > y:
    print(x)
else:
    print(y)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
first = input()
(sA, sB, sC,sD) = first.split()
ab = int(sA)*int(sB)
cd = int(sC)*int(sD)
if ab>cd:
    print(ab)
else:
    print(cd)

Solution (Python):
(A, B, C, D) = map(int, input().split())
print(max(A*B, C*D))

Solution (Python):


def main():
    line = input()
    (sA, sB, sC, sD) = line.split()
    A = int(sA)
    B = int(sB)
    C = int(sC)
    D = int(sD)
    area1 = A * B
    area2 = C * D
    if area1 > area2:
        answer = area1
    else:
        answer = area2
    print(answer)

main()

Solution (Python):
A, B, C, D = map(int, input().split())
print(max(A*B, C*D))

Solution (Python):
A,B,C,D  =  list(map(int,input().split(' ')))

AB = A*B
CD = C*D
if AB == CD:
  print(AB)
else:
  print(max(AB,CD))

Solution (Python):
a,b,c,d = map(int,input().split())
print(int(max(a*b,c*d)))

Solution (Python):
A,B,C,D = map(int,input().split())
print([A*B,C*D][A*B<C*D])

Solution (Python):
A,B,C,D = map(int, input().split())
print(A*B if A*B > C*D else C*D)

Solution (Python):
A, B, C, D = [int(i) for i in input().split()]
print(max(A * B, C * D))

Solution (Python):
a,b,c,d = map(int,input().split())

print(max(a*b,c*d))

Solution (Python):
def abc():
    a, b, c, d = map(int, input().split())
    print(max(a * b, c * d))


abc()

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):

a, b, c, d = map(int, input().split())
if a * b >= c * d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a,b,c,d = map(int,input().split())
if a * b >= c * d:
  print(a * b)
else:
  print(c * d)

Solution (Python):
a,b,c,d=map(int,input().split())

print(max(a*b,c*d))

Solution (Python):
A,B,C,D=map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a,b,c,d = map(int, input().split())
if a * b <= c * d:
    print(c*d)
else:
    print(a*b)

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
A, B, C, D = list(map(int, input().split()))
if A * B >= C * D:
    print(A * B)
else:
    print(C * D)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d=(int(i) for i in input().split())
if (a*b>c*d):
    print(a*b)
else:
    print(c*d)

Solution (Python):
a, b, c, d = map(int, input().split())
x = a * b
y = c * d
if x > y:
    print(x)
elif y > x:
    print(y)
else:
    print(x)

Solution (Python):


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

print(max(a*b, c*d))

Solution (Python):
A,B,C,D = list(map(int,input().split(" ")))
print(max(A*B,C*D))

Solution (Python):
a, b, c, d = map(int, input().split())
ab = a*b
cd = c*d
if ab > cd:
    print(ab)
else:
    print(cd)

Solution (Python):
A, B, C, D = [int(x) for x in input().split()]
print(A*B) if A*B >= C*D else print(C*D)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
A, B, C, D = map(int, input().split())

print(max(A * B, C * D))

Solution (Python):
a, b, c, d = map(int, input().split())






area1 = a * b
area2 = c * d




if area1 == area2:
    print(area1)
elif area1 > area2:
    print(area1)
else:
    print(area2)

Solution (Python):

"""
A - Two Rectangles
https://atcoder.jp/contests/abc052/tasks/abc052_a

"""
import sys


def solve(A, B, C, D):
    return max(A*B, C*D)


def main(args):
    A, B, C, D = map(int, input().split())
    ans = solve(A, B, C, D)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
def larger(x, y):
	if x > y: return x
	return y

A, B, C, D = map(int, input().split())
print(larger(A*B, C*D))

Solution (Python):
A, B, C, D = map(int, input().split())
print(max(A*B, C*D))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A, B, C, D = map(int, input().split(' '))

sum_A = A * B
sum_B = C * D

if sum_A > sum_B:
    print(sum_A)
else:
    print(sum_B)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, raw_input().split())
x = a * b
y = c * d
if x > y:
    print x
else:
    print y

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 

A,B,C,D = map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a,b,c,d = map(int,input().split())
print(a*b if a*b > c*d else c*d)

Solution (Python):
a,b,c,d=map(int,input().split())

if a*b>c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
A,B,C,D = map(int, input().split())

ract_x = A * B
ract_y = C * D

if ract_x > ract_y:
    print(ract_x)
else:
    print(ract_y)

Solution (Python):
a,b,c,d = map(int, input().split())
print(max(a*b,c*d))

Solution (Python):

import sys
def input(): return sys.stdin.readline().rstrip()
def mi(): return map(int, input().split())


A,B,C,D = mi()

print(max(A*B, C*D))

Solution (Python):
a, b, c, d = [ int(v) for v in input().split() ]

print(max(a*b,c*d))

Solution (Python):
A,B,C,D=map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a,b,c,d = map(int, input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int, input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int, input().split())
print(max(a*b,c*d))

Solution (Python):
A, B, C, D = input().split()

print(max(int(A) * int(B), int(C) * int(D)))

Solution (Python):
a, b, c, d = map(int, input().split())
if a * b == c * d:
  print(a * b)
else:
  print(max(a * b, c * d))

Solution (Python):
A,B,C,D = map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
input_data=input().split()


first_area = int(input_data[0]) * int(input_data[1])
second_area = int(input_data[2]) * int(input_data[3])

if first_area >= second_area :
  print(first_area)
else:
  print(second_area)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
import sys
import math

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

if a*b>=c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
import sys
import math

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

if a*b>=c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b, c*d))

Solution (Python):


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


if a*b >= c*d :
    print(a*b)
else :
    print(c*d)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A,B,C,D = map(int,input().split())
if A * B >= C * D:
    print(A * B)
else:
    print(C * D)

Solution (Python):
A, B, C, D = map(int, input().split())
print((A*B) if (A*B)>(C*D) else (C*D));

Solution (Python):
a,b,c,d=map(int,input().split())

if a*b >= c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int, input().split())
if a*b > c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a, b, c, d = [int(x) for x in input().split()]
print(max(a*b, c*d))

Solution (Python):
A, B, C, D = map(int, input().split())

print(max(A * B, C * D))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())

print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d = map(int, input().split())

print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split());print(max(a*b,c*d))

Solution (Python):
l = list(map(int, input().split()))

one = l[0] * l[1]
two = l[2] * l[3]

if one < two:
    print(two)
else:
    print(one)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
A,B,C,D=map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
A,B,C,D=map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a, b, c, d = map(int, input().split())
if(a*b>c*d):
    print(a*b)
else:
    print(c*d)

Solution (Python):
A, B, C, D = map(int, input().split())

print(max([A*B,C*D]))

Solution (Python):


def solve(A, B, C, D):
    print(A*B if A*B>C*D else C*D)

if __name__ == '__main__':
    A, B, C, D = map(int, input().split())
    
    solve(A, B, C, D)

Solution (Python):
a,b,c,d=map(int,input().split())
if a*b>=c*d:
  print(int(a*b))
else:
  print(int(c*d))

Solution (Python):
A, B, C, D = map(int, input().split())
S1, S2 = A * B, C * D
print(S1 if S1 >= S2 else S2)

Solution (Python):
A,B,C,D = map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
A, B, C, D = map(int, input().split())
if (A * B) > (C * D):
    print(A * B)
else:
    print(C * D)

Solution (Python):
a,b,c,d=map(int, input().split(" "))
print(a*b if a*b>c*d else c*d)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A,B,C,D = map(int,input().split(" "))
print(max(A*B,C*D))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a, b, c, d =[int(i) for i in input().split()]
print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d=map(int,input().split());print(max([a*b,c*d]))

Solution (Python):
a,b,c,d = map(int,input().split())
print(a*b if a*b>c*d else c*d)

Solution (Python):
A,B,C,D = map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
a, b, c, d = [int(n) for n in input().split()]
print(max(a*b, c*d))

Solution (Python):
a, b, c, d = map(int, input().split())

x = a * b
y = c * d

if x > y:
    print(x)
else:
    print(y)

Solution (Python):
a,b,c,d = map(int,input().split())
print(a*b if a*b>=c*d else c*d)

Solution (Python):
A, B, C, D = map(int, input().split())
if A*B > C*D:
    print(A*B)
else:
    print(C*D)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
A, B, C, D = map(int,input().split())
print(max(A*B, C*D))

Solution (Python):
A,B,C,D=map(int,input().split())
print(A*B if A*B>C*D else C*D)

Solution (Python):
a,b,c,d = map(int,input().rstrip().split(' '))

if a*b > c*d :
    print(a*b)
else:
    print(c*d)

Solution (Python):
a,b,c,d=map(int,input().split())

A=a*b
C=c*d

print(int(max(A,C)))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int, input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d=map(int,input().split());print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
def main():
	A, B, C, D = map(int, input().split())
	print(max(A*B, C*D))


if __name__ == '__main__':
	main()

Solution (Python):
a = list(map(int,input().split()))
b = a[0] * a[1]
c = a[2] * a[3]

if b > c:
  print(b)
else:
  print(c)

Solution (Python):


def read_input():
    a, b, c, d = map(int, input().split())
    return a*b, c*d

def submit():
    a, b = read_input()

    print(max(a, b))

if __name__ == '__main__':
    submit()

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A, B, C, D = map(int, input().split())

print(A*B if A*B >= C*D else C*D)

Solution (Python):
a,b,c,d = map(int, input().split())
print(a*b if c*d<a*b else c*d)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A, B, C, D = map(int, input().split())
print(max(A*B, C*D))

Solution (Python):
A, B, C, D = map(int, input().split())
print(max(A*B, C*D))

Solution (Python):
a,b,c,d=map(int,input().split())
print(a*b if a*b>c*d else c*d)

Solution (Python):
a, b, c, d = map(int, input().split())

if a * b > c * d:
    print(a * b)
elif a * b == c * d:
    print(a * b)
else:
    print(c * d)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
x=a*b
y=c*d
if x>y:
    print(x)
elif y>x:
    print(y)
else:
    print(x)

Solution (Python):
a,b,c,d = map(int,input().split())
sq1 = a * b
sq2 = c * d
sq = max(sq1,sq2)
print(sq)

Solution (Python):
A, B, C, D = map(int, input().split())
X = A * B
Y = C * D
if X > Y:
    print(X)
else:
    print(Y)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
if a*b >= c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
a, b, c, d = map(int, input().split())

if(a * b < c * d):
    print(c * d)
elif(a * b > c * d):
    print(a * b)
else:
    print(a * b)

Solution (Python):


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

print(max(a*b, c*d))

Solution (Python):
A, B, C, D = map(int, input().split())
S1 = A * B
S2 = C * D
print(max(S1, S2))

Solution (Python):
a, b, c, d = (int(i) for i in input().split())  
print(int(max(a*b,c*d)))

Solution (Python):
a,b,c,d=input().split()

x=int(a)*int(b)
y=int(c)*int(d)

if x>y:
    print(x)

elif x<y:
    print(y)

else:
    print(x)

Solution (Python):
import functools

import os
import sys

sys.setrecursionlimit(10000)
INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


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


def inlf():
    return list(map(float, input().split()))


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


def inpm(line):
    return [inp() for _ in range(line)]


def inpfm(line):
    return [inpf() for _ in range(line)]


def inpsm(line):
    return [inps() for _ in range(line)]


def inlm(line):
    return [inl() for _ in range(line)]


def inlfm(line):
    return [inlf() for _ in range(line)]


def inlsm(line):
    return [inls() for _ in range(line)]


def Yesif(cond):
    print('Yes' if cond else 'No')


def YESIF(cond):
    print('YES' if cond else 'NO')


def yesif(cond):
    print('yes' if cond else 'no')



a, b, c , d = inl()
print(max(a*b, c*d))

Solution (Python):

a, b, c, d = list(map(int, input().rstrip().split()))
print(max(a * b, c * d))

Solution (Python):
A, B, C, D = map(int, input().split())
if A * B >= C * D:
    print(A * B)
else:
    print(C * D)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
a, b, c, d = map(int, input().split())
if(a*b==c*d):
    print(a*b)
else:
    print(max(a * b, c * d))

Solution (Python):
a = list(map(int,input().split()))
print(max(a[0]*a[1],a[2]*a[3]))

Solution (Python):
A, B, C, D=map(int, input().split())

X=A*B
Y=C*D

print(X) if X>=Y else print(Y)

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a,b,c,d = map(int,input().split())
s = a*b
t = c*d 
if s > t:
    print(s)
else:
    print(t)

Solution (Python):
a,b,c,d=map(int, input().split())

print(max(a*b, c*d))

Solution (Python):
a,b,c,d=map(int,input().split())
A=a*b
B=c*d
print(A if A>=B else B)

Solution (Python):
a,b,c,d=map(int,input().split())
if a*b >= c*d:
  print(a*b)
else:
  print(c*d)

Solution (Python):
a,b,c,d = [int(i) for i in input().split(" ")]
print(max(a*b, c*d))

Solution (Python):
a, b, c, d = [int(item) for item in input().split()]
print(max(a*b, c*d))

Solution (Python):
a,b,c,d = map(int,input().split())

print(max(a*b,c*d))

Solution (Python):
A,B,C,D = map(int,input().split())
print(max(A*B,C*D))

Solution (Python):
A,B,C,D = map(int,input().split())
if A*B <= C*D:
    print(C*D)
else:
    print(A*B)

Solution (Python):
a,b,c,d=map(int,input().split())
a1 = a*b
a2 = c*d
if a1 > a2:
    print(a1)
elif a1<a2:
    print(a2)
else:
    print(a1)

Solution (Python):
a,b,c,d = map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
a = list(map(int, input().split()))
b = a[0]*a[1]
c = a[2]*a[3]
if b >= c:
    print(b)
else:
    print(c)

Solution (Python):
a, b, c, d = map(int, input().split())
print(max(a * b, c * d))

Solution (Python):
a,b,c,d=map(int,input().split())
print(max(a*b,c*d))

Solution (Python):
A, B, C, D = map(int, input().split())
print(A*B if A*B >= C*D else C*D)

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    A = list(map(int, input().split()))
    return max(A[0] * A[1], A[2] * A[3])


if __name__ == '__main__':
    print(main())

Solution (Python):
a,b,c,d = map(int,input().split())
ans = max(a*b,c*d)
print(ans)

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    a,b,c,d = f()
    print(max(a*b, c*d))

solve()