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

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

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

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 sys import stdin

a, b, c, d = [int(x) for x in stdin.readline().rstrip().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())
men_1 = A * B
men_2 = C * D
print(max(men_1, men_2))

Solution (Python):
from functools import reduce

def main():
    
    
    
    
    
    
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    

    a, b, c, d = (int(_) for _ in 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())
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 = 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())

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

X=a*b
Y=c*d

if X==Y:
    print(X)
elif X>Y:
    print(X)
elif Y>X:
    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())

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 two_rectangles(A: int, B: int, C: int, D: int)->int:
    return max(A*B, C*D)


if __name__ == "__main__":
    A, B, C, D = map(int, input().split())
    ans = two_rectangles(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())
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*int(a*b>=c*d)+c*d*int(a*b<c*d))

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

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

Solution (Python):

from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


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



"""
def factor(n):
    i = 2
    m = n
    while m >= i:
        while m%i == 0:
            m //= i
            d[i] += 1
            d[i] %= mod
            if m < i:break
        i += 1
n = I()
d = defaultdict(int)
for i in range(2,n+1):
    factor(i)
ans = 1
for i in d.values():
    ans *= i+1
    ans %= mod
print(ans)
"""


"""
n,a,b = LI()
x = LI()
ans = 0
for i in range(n-1):
    if a*(x[i+1]-x[i]) > b:
        ans += b
    else:
        ans += a*(x[i+1]-x[i])
print(ans)
"""

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

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

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

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

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

Solution (Python):


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

if square1 == square2:
    print(square1)
elif square1 > square2:
    print(square1)
else:
    print(square2)

Solution (Python):
[A,B,C,D] = list(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 = 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:
    a,b = c,d
print(a*b)

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(i) for i in input().split())

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
from collections import Counter
from itertools import product
from math import factorial


primes = list(range(int(10**5) + 1))
primes[1] = 0
for i in range(2, int(len(primes) ** 0.5) + 1):
    if primes[i]:
        for j in range(2 * i, len(primes), i):
            primes[j] = 0

def main():
    A, B, C, D = LI()
    return max(A * B, C * D)

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

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

s1 = a*b
s2 = c*d

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

Solution (Python):
def main() -> None:
    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())
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)
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())
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())
x = a*b
y = c*d
if x!= y:
  print(max(x,y))
elif x==y:
  print(x)

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

Solution (Python):

h1, w1, h2, w2 = map(int, input().split())
rect1 = h1*w1
rect2 = h2*w2
if rect1 == rect2:
    print(rect1)
else:
    print(max(rect1,rect2))

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 = 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())
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 = input().split()
area = lambda length, width: length * width
area1 = area(int(a),int(b))
area2 =area(int(c),int(d))
if(area1 >= area2):
    print(area1)
else:
    print(area2)

Solution (Python):
from sys import stdin
a, b, c, d = [int(x) for x in stdin.readline().rstrip().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 ab < cd:
    print(cd)
else:
    print(ab)

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

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

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

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=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("{}".format(a*b))
elif (a*b < c*d):
    print("{}".format(c*d))
else:
    print("{}".format(a*b))

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())
x,y=a*b,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())
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,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())
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(x) for x in input().split() ]

a = A * B
b = C * D
ans = max(a, b)

print(ans)
print()

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, 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(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,raw_input().split())
print max(A*B,C*D)

Solution (Python):
s=input().split()
a1=int(s[0])*int(s[1])
a2=int(s[2])*int(s[3])
if a1 >= a2:
    print(a1)
else:
    print(a2)

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

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

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

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())
s1=a*b
s2=c*d
def fun():
     print(11)
     print(22)
     print(33)
     print(22) 
s=max(s1,s2)
print(s)

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,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 = [int(_) for _ 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(A * B if C * D < A * B else 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())
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())
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):


import sys

INF = float('inf')
MOD = 10 ** 9 + 7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()


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

Solution (Python):
""" AtCoder """

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, = map(int, input().split())
print(max(a[0]*a[1], a[2]*a[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) 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())
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(int(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())
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)
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(a*b if a*b >= c*d else c*d)

Solution (Python):
A, B, C, D = [int(x) for x in 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())
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_list = [a * b, c * d]

print(max(ans_list))

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

Solution (Python):
x = [int(i) for i in 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(A*B) if (A*B) >= (C*D) 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(a*b if a*b>=c*d else c*d)

Solution (Python):
int_a, int_b, int_c, int_d = map(int, input().split())

print(int_a * int_b if int_a * int_b >= int_c * int_d else int_c * int_d)

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

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(max(A[0]*A[1],A[2]*A[3]))

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

Solution (Python):
H1,W1,H2,W2 = map(int,input().split())
if H1 * W1 > H2 * W2:
  ans = H1 * W1
else:
  ans = H2 * W2
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())

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())
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(x) for x in 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()]
s = a*b
if (s < c*d) :
    s = c*d

print(s)

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

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):
def main():
    a, b, c, d = map(int, input().split())
    areas = sorted([a * b, c * d])
    print(areas[1])


if __name__ == '__main__':
    main()

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


if __name__ == '__main__':
    main()

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):
from statistics import mean, median,variance,stdev
import sys
import math

x = input().split()

a = []
for i in range(len(x)):
   a.append(int(x[i]))

if a[0]*a[1]<a[2]*a[3]:print(a[2]*a[3])
else:print(a[0]*a[1])

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

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("{}".format(max(A*B,C*D)))

Solution (Python):



def main():
    """Function."""
    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 = [int(_) for _ 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 = map(int, raw_input().split())

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

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

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

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

ab = A * B
cd = C * D
result = max(ab, cd)
print(result)

Solution (Python):
import sys
import math
import collections
import itertools
import array
import inspect


sys.setrecursionlimit(1000000)



def chkprint(*args):
    names = {
        id(v): k
        for k, v in inspect.currentframe().f_back.f_locals.items()
    }
    print(', '.join(
        names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))



def to_bin(x):
    return bin(x)[2:]


def li_input():
    return [int(_) for _ in input().split()]


def gcd(n, m):
    if n % m == 0:
        return m
    else:
        return gcd(m, n % m)


def gcd_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = gcd(v, L[i])

    return v


def lcm(n, m):
    return (n * m) // gcd(n, m)


def lcm_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = lcm(v, L[i])

    return v



def wfs_d(D, N, K):
    """
    D: 隣接行列(距離付き)
    N: ノード数
    K: 始点ノード
    """

    dfk = [-1] * (N + 1)
    dfk[K] = 0

    cps = [(K, 0)]
    r = [False] * (N + 1)
    r[K] = True
    while len(cps) != 0:
        n_cps = []
        for cp, cd in cps:
            for i, dfcp in enumerate(D[cp]):
                if dfcp != -1 and not r[i]:
                    dfk[i] = cd + dfcp
                    n_cps.append((i, cd + dfcp))
                    r[i] = True

        cps = n_cps[:]

    return dfk



def dfs_d(v, pre, dist):
    """
    v:  現在のノード
    pre: １つ前のノード
    dist: 現在の距離

    以下は別途用意する
    D: 隣接リスト(行列ではない)
    D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
    """

    global D
    global D_dfs_d

    D_dfs_d[v] = dist

    for next_v, d in D[v]:
        if next_v != pre:
            dfs_d(next_v, v, dist + d)

    return


def sigma(N):
    ans = 0
    for i in range(1, N + 1):
        ans += i
    return ans


def comb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2, r + 1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p - 1, r, p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def bisearch(L, target):
    low = 0
    high = len(L) - 1
    
    while low <= high:
        mid = (low + high) // 2
        guess = L[mid]
        if guess == target:
            return True
        elif guess < target:
            low = mid + 1
        elif guess > target:
            high = mid - 1
    if guess != target:
        return False



dp = None


def main():
    A, B, C, D = li_input()

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


main()

Solution (Python):
orline = input().split()
line = []
for i in range(len(orline)):
    line.append(int(orline[i]))  
sq1 = line[0] * line[1]
sq2 = line[2] * line[3]
if sq1 >= sq2:
    print(sq1)
else:
    print(sq2)

Solution (Python):
def big(w1, h1, w2, h2):
    if w1*h1 > w2*h2:
        return w1*h1
    else:
        return w2*h2

a=list(map(int,input().split()))
print(str(big(a[0],a[1],a[2],a[3])))

Solution (Python):
a=input().strip().split(" ")

b=[int(i) for i in a]

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

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

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())
L = [a*b, c*d]
L.sort()
print(L[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())

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

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

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

""" Two Rectangles """

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

if __name__ == '__main__':
    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())

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

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

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):
x,y,z,w = map(int, input().split())

if x*y >= z*w:
        print(x*y)
else:
        print(z*w)

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 = 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,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,c*d][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())
e=a*b
f=c*d
if e>f:
  print(e)
elif e<f:
  print(f)
else:
  print(e)