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

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c, d = list(map(int, input().rstrip('\n').split()))
    print(max(a * b, c * d))


if __name__ == '__main__':
    slove()

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

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())
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 = (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):
input_ = input().split()
A, B, C, D = input_

s1 = int(A) * int(B)
s2 = int(C) * int(D)

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

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

areaone = a[0]*a[1]
areatwo = a[2]*a[3]

if areaone == areatwo:
    print(areatwo)
else:
    print(max(areatwo,areaone))

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

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
B = c * d
if A > B:
  print(A)
elif A < B:
  print(B)
elif A == B:
  print(A)
else:
  pass

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):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
def do():
    a,b,c,d = INTM()
    print(max(a*b,c*d))
if __name__ == '__main__':
    do()

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(s) for s 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())
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 = 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())

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

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

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


if __name__ == "__main__":
    resolve()

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

Solution (Python):
import sys
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

A,B,C,D = IL()
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):
x=list(input().split())
a=int(x[0])
b=int(x[1])
c=int(x[2])
d=int(x[3])
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):
import sys
input = sys.stdin.readline

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

sq = [a * b, c * d]

if sq[0] > sq[1]:
    ans = sq[0]
else:
    ans = sq[1]

print(ans)

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 = (int(x) for x 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)
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):
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=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)
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(max(a*b,c*d))

Solution (Python):
height1, horizontal1, height2, horizontal2 = map(int, input().split())

ans = max(height1 * horizontal1, height2 * horizontal2)
print(ans)

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

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

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

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
    
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(int(c*d))
else:
  print(int(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())
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(a*b if a*b >= c*d else c*d )

Solution (Python):
N = input().split()
A, B, C, D = int(N[0]), int(N[1]), int(N[2]), int(N[3])
if A * B > C * D:
    print(A * B)
elif A * B < C * D:
    print(C * D)
else:
    print(C * D)

Solution (Python):
def cal(h1,w1,h2,w2):
    S1=h1*w1
    S2=h2*w2
    if S1>=S2:
        return S1
    else:
        return S2

h1,w1,h2,w2=map(int,input().split(" "))
print(cal(h1,w1,h2,w2))

Solution (Python):
a = [int(_) for _ in input().split()]
if all(1 <= i <= 10 ** 4 for i in a):
    print(max(a[0] * a[1], a[2] * a[3]))
else:
    print('hoge!')

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

Solution (Python):
import sys
import copy
import string
import  math
from _bisect import *
from collections import *
from operator import itemgetter
from math import factorial
"""
from fractions import gcd
def lcm(x, y):
    return (x * y) // gcd(x, y)
"""
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

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

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

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

x = a*b
y = c*d

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

Solution (Python):
A,B,C,D = (int(i) for i in 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())
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())

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

Solution (Python):
A,B,C,D = map(int, input().strip().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, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, 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 = list(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())
if a*b >= c*d:
  print(a*b)
else:
  print(c*d)

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

S1=A*B
S2=C*D

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

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

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush, heapify
import math
import itertools
import random
 




 
INF = float('inf')
def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
 
def main():
    A,B,C,D = inputMap()
    tmp = A*B
    tmp2 = C*D
    print(max(tmp,tmp2))
    
    
if __name__ == "__main__":
	main()

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
sys.setrecursionlimit(10**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 sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

from functools import lru_cache


def main(): 
    a,b,c,d  = LI()

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

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

Solution (Python):
l = list(map(int, input().split()))
print(max([i*j for i, j in zip(l[::2], l[1::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())
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 test():
    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)


if __name__ == "__main__":
    test()

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=input().split()
a=int(a)
b=int(b)
c=int(c)
d=int(d)
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) if a*b!=c*d else 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())
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):
li = list(map(int,input().split()))
A = li[0]
B = li[1]
C = li[2]
D = li[3]

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

Solution (Python):

s = raw_input()
array_num = [ int(each_num) for each_num in s.split()]
first_area = array_num[0] * array_num[1]
second_area = array_num[2] * array_num[3] 
if first_area > second_area:
	print(first_area)
elif first_area < second_area:
	print(second_area)
else:
	print(first_area)

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

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 = [int(i) for i in 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 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 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 = input().split()
ab = int(a) * int(b)
cd = int(c) * int(d)
if  ab > cd:
    print(ab)
else:
    print(cd)

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):
N = list(map(int, input().split()))
s1 = N[0] * N[1]
s2 = N[2] * N[3]
print(max(s1, 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())
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())
x = a*b
y = c*d
print(max(x, 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())
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().rstrip().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())
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,raw_input().split())
cal_1 = A*B
cal_2 = C*D
if cal_1 > cal_2:
    print cal_1
else:
    print cal_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())

N1 = A*B
N2 = C*D

if N1 > N2:
  Ans=N1
else:
  Ans=N2

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=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 = 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
input = sys.stdin.readline

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

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

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

R1 = A*B
R2 = C*D
print(max(R1, R2))

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

Solution (Python):

A,B,C,D = [int(i) for i in 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 = map(int, input().split(' '))
print(max(a * b, c * d))

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

if t1 > t2 or t1 == t2:
    print(t1)
else:
    print(t2)

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

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

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

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

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