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):
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, s2 = a*b, c*d
if s1 >= s2:
    print(s1)
else:
    print(s2)

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

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())
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())
ans = max(A*B, C*D)
print(ans)

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

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

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

if rec1 >= rec2:
    print(rec1)

else:
    print(rec2)

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

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

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

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())
s=A*B
t=C*D
if s==t:
    print(s)
else:
    print(max(s,t))

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

A=a*b
B=c*d

if A>=B:
  print(A)
else:
  print(B)

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

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

Solution (Python):
N = [int(e) for e in input().split()]
a = N[0]
b = N[1]
c = N[2]
d = N[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())

square_1 = a * b
square_2 = c * d

if square_1 >= square_2:
    print(square_1)
else:
    print(square_2)

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)
elif 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 = map(int, input().split())
if a * b >= c * d:
  print(a * b)
else:
  print(c * d)

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

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)
else:
    print(a * b)

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=map(int,input().split())
if A*B>C*D:
    print(A*B)
elif A*B<C*D:
    print(C*D)
elif 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):
x=list(map(int,input().split()))
print(max(x[0]*x[1],x[2]*x[3]))

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):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

a, b, c, d = na()

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):
A,B,C,D = input().split(" ")
a= int(A)
b= int(B)
c= int(C)
d= int(D)
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())
if a*b>=c*d:
    print(a*b)
else:
    print(c*d)

Solution (Python):
icase=0
if icase==0:
    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())
    S1 = A*B
    S2 = C*D

    if S1 > S2:
        print(S1)
    elif S1 < S2:
        print(S2)
    else:
        print(S1)
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())

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(s1)
else:
    print(s2)

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

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

Solution (Python):

import sys


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



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

S1 = a * b
S2 = 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())

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

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

S1 = int(A*B)
S2 = int(C*D)

if S1 >= S2:
    print(S1)
elif S2 > S1:
    print(S2)

Solution (Python):
n,m,k,j=map(int,input().split())
print(max(n*m,k*j))

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):
import sys

input = sys.stdin.readline


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


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

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):
a,b,c,d = map(int, input().split())
print(max(a*b,c*d))

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

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

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

rec_a = A * B
rec_b = C * D

if rec_a >= rec_b:
    print(rec_a)
else :
    print(rec_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 = 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())

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())
A = a*b
B = c*d
print(max(A,B))

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):
li = list(map(int,input().split()))
rect_a = li[0]*li[1]
rect_b = li[2]*li[3]
if rect_a > rect_b:
    print(str(rect_a))
else:
    print(str(rect_b))

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())
ans1=a*b
ans2=c*d
if ans1>ans2:
  print(ans1)
elif ans1<ans2:
  print(ans2)
else:
  print(ans1)

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

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

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

ab = a*b
cd = c*d

if ab==cd :
  print(ab)
elif 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())
e=a*b
o=c*d
if e<=o:
    print(o)
else:
    print(e)

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
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

a, b, c, d = map(int, readline().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()))
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 = 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())
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())
if a * b > c * d:
    print(a*b)
else:
    print(c*d)

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

Solution (Python):
A,B,C,D=(int(x) for x in input().split())

X = A * B
Y = C * D

if X == Y or X > Y:
    print(X)

elif X < Y:
    print(Y)

Solution (Python):
a,b,c,d = map(int,input().split())
def main():
  print(a * b if (a*b>c*d) else 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):
	answer = A * B
elif (C * D) > (A * B):
	answer = C * D
elif (A * B) == (C * D):
	answer = C * D
print(answer)

Solution (Python):

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

Solution (Python):
import sys

a, b, c, d = map(int, sys.stdin.readline().split())

def main():
    ans = max(a * b, c * d)
    print(ans)

if __name__ ==  '__main__':
    main()

Solution (Python):

a, b, c, d = [int(x) for x in 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):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    maxnum = max(a[0]*a[1],a[2]*a[3])
    print(maxnum)

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())
areaA = A*B
areaB = C*D
result = areaA if (areaA > areaB) else areaB
print(result)

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

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

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 = list(map(int, input().split()))


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

Solution (Python):
import math

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())
ans = max(A*B,C*D)
print(ans)

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
if ab>cd:print(ab)
elif cd>ab:print(cd)
else:print(ab)

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


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 = [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=list(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())

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())
if a*b>c*d:
  print a*b
elif c*d>a*b:
  print c*d
elif c*d==a*b:
  print (c*d + a*b)/2

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())
ab = a*b
cd = c*d
if ab>cd:
  print(ab)
elif ab < cd:
  print(cd)
else:
  print(cd)

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(a*b if a*b>c*d else c*d if a*b<c*d else 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())

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):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    a,b,c,d=MI()
    print(max(a*b,c*d))
main()

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(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, open(0).read().split())
print(max(a*b, c*d))

Solution (Python):
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    a,b,c,d=MI()
    print(max(a*b,c*d))

main()

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

if k>=l:
  print(k)
else:
  print(l)

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:
  ans = a*b
else:
  ans = c*d
print(ans)

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())
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()))
a=a*b
c=c*d
if a>c:
  print(a)
elif a<=c:
  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(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 os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, C, D = list(map(int, sys.stdin.readline().split()))
    print(max(A*B, C*D))


if __name__ == '__main__':
    main()

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())
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 = list(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())
S1 = a *b
S2 = c * d
l = [S1, S2]
print(max(l))

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

Solution (Python):
import sys

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

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

    return


resolve()

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

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

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

print(max(data[0]*data[1] , data[2]*data[3]))

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

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 = 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())
print(a * b if a*b > c*d else c * d)

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

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

Solution (Python):
a,b,c,d = (int(x) for x 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):
input1 = list(map(int,input().split()))
A = input1[0]
B = input1[1]
C = input1[2]
D = input1[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())
print(max(a*b,c*d))

Solution (Python):
import sys
readline = sys.stdin.buffer.readline

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

class Square():
    def __init__(self,a,b,c,d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d
    
    def require(self,ab_or_cd=0):
        if ab_or_cd==0:
            return self.a * self.b
        else:
            return self.c * self.d
    
    def compare(self):
        print(self.require(0) if self.require(0) >= self.require(1) \
            else self.require(1))

x = Square(a,b,c,d)
x.compare()

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

ab = a * b
cd = c * d

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

Solution (Python):

import sys


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


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())
print(max(a*b,c*d))

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


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())
print(max(a*b,c*d))

Solution (Python):



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

area1 = A*B
area2 = C*D

print( max(area1,area2) )

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

kekka1 = a*b
kekka2 = c*d

if kekka1 == kekka2:
    print(int(kekka1))
elif kekka1 > kekka2:
    print(int(kekka1))
else:
    print(int(kekka2))

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

m = a*b
n = c*d

if m > n:
    print(m)
else:
    print(n)

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

Solution (Python):
print(eval("max(" + input().replace(" ", "*", 1).replace(" ", ",", 1).replace(" ", "*", 1) + ")"))

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

A = a*b
B = c*d

if A>B:
    print(A)
elif B>A:
    print(B)
elif A==B:
    print(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())

if a * b > c * d:
	print(a * b)
elif 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 = 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)
elif A * B < C * D:
    print(C * D)
else:
    print(A * 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 = 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())
S_AB = A * B
S_CD = C * D
if S_AB > S_CD:
    print(S_AB)
else:
    print(S_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())

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)
elif a * b < c * d:
  print(c * d)
else:
  print(a * b)

Solution (Python):
a, b, c, d = list(map(int, input().split()))
print(a*b) if a*b >= c*d 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)
else:
    print(A*B)

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

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

volume1 = A * B
volume2 = C * D

if volume1 > volume2:
    print(volume1)
else:
    print(volume2)

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)
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):
e = [int(e) for e in input().split()]
area_1 = e[0] * e[1]
area_2 = e[2] * e[3]
if area_1 >= area_2:
    print(area_1)
else:
    print(area_2)

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(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())
if A*B > C*D:
  print(A*B)
else:
  print(C*D)

Solution (Python):
a,b,c,d=list(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 = list(map(int, input().split()))
if A*B >= C*D:
    print(A*B)
else:
    print(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):
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) 
elif (a*b) < (c*d) :
  print(c*d) 
else : 
  print(a*b)

Solution (Python):

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


area1 = A * B
area2 = C * D

print(max(area1, area2))

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

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):
A, B, C, D = map(int, input().split())
print(max(A * B, C * D))

Solution (Python):
import sys
input = sys.stdin.readline
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):
arr_int = [int(s) for s in input().split(" ")]

if(( arr_int[0]* arr_int[1]) > (arr_int[2]* arr_int[3])):
	print(arr_int[0]* arr_int[1] )
else:
	print(arr_int[2]* arr_int[3])

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