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

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

Solution (Python):




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

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

Solution (Python):
"""
author : halo2halo
date : 31, Jan, 2020
"""

import sys
import itertools



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A,B,C,D=map(int,readline().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(a*b if a*b>c*d else c*d)

Solution (Python):
A,B,C,D = map(int,input().split())
ab = A * B
cd = C * D
print(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 = [int(x) for x 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())

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

print(ans)

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

Solution (Python):
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())
x=a*b
y=c*d
if x<=y:
    print(y)
else:
    print(x)

Solution (Python):

import sys
INF = float("inf")


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


def main():

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


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    from sys import stdin, setrecursionlimit
    
    
    r = stdin.readline()[:-1]
    
    
    
    
    
    
    a,b,c,d = map(int, r.split())
    
    
    

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

if __name__ == '__main__':
    main()

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)

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

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

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

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

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

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

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

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


if __name__ == '__main__':
    res = solve()
    print(res)

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

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

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

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

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

Solution (Python):
len = input().split()
len_i = [int(s) for s in len]

area1 = len_i[0] * len_i[1]
area2 = len_i[2] * len_i[3]

print(max(area1, area2))

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)

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

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

a = lengthArray[0]*lengthArray[1]
b = lengthArray[2]*lengthArray[3]

if a<b:
  print(b)
else:
  print(a)

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

Solution (Python):


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

t1 = a * b
t2 = c * d

if t1 < t2 :
   print(t2)
else :
   print(t1)

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

Solution (Python):
A, B, C, D = [int(s) for s in input().split()]
print(sorted([A * B, C * D])[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())
print(a*b if a*b>=c*d else c*d)

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

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

print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
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=list(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(lambda x: int(x), input().split())

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

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

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

Solution (Python):
A, B, C, D = map(int, input().split())
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 = 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):
[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())

area1 = a * b
area2 = c * d

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

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):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

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

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

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

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

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

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

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)

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

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

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

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


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

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

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

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

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

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

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf')
ans = 0 ;count = 0 ;pro = 1

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 print(c*d)

Solution (Python):
import sys

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

Solution (Python):
import sys

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

def main():
    area1 = a * b
    area2 = c * d
    return area1 if area1 >= area2 else area2
    
if __name__ == '__main__':
    ans = main()
    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() )

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

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

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

Solution (Python):
a,b,c,d = map(int, input().split())
rectangle1 = a * b
rectangle2 = c * d
ans = max(rectangle1, rectangle2)
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=map(int,input().split())
print(a*b if a*b>c*d else 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
print(max(x,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, open(0).read().split())
if A*B >= C*D:
  print(A*B)
else:
  print(C*D)

Solution (Python):
A, B, C, D = map(int, open(0).read().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):
first_high, first_width,second_high, second_width = map(int,input().split())

first_place = first_high * first_width
second_place = second_high * second_width

if first_place >= second_place:
	print(first_place)
else:
	print(second_place)

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

r1 = a * b
r2 = c * d
print(max(r1, r2))

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

area1 = a * b
area2 = c * d

area_list = [area1, area2]
area_list.sort()

print(area_list[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())
s1=A*B
s2=C*D
if s1==s2:
    print(s1)
elif 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())
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):
from sys import stdin

a,b,c,d = [int(x) for x in stdin.readline().rstrip().split()]

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

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

x = a*b
y = c*d

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

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

Solution (Python):
def judge(A,B,C,D):
    S1 = A*B
    S2 = C*D
    if S1>=S2:
        print(S1)
    else:
        print(S2)

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

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

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

A=a*b
B=c*d

if A>B:
  print(A)
else:
  print(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 = list(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 sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    a,b,c,d = MI()
    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())
if a * b >= c * d:
  print(a * b)
else:
  print(c * d)

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

A_B = (A*B)
C_D = (C*D)

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

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

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

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

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

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

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

import sys
input = sys.stdin.readline


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

first = A*B
second = C*D

if first >= second:
  print(first)
else:
  print(second)

Solution (Python):
def examA():
    A, B, C, D = LI()
    ans = max(A*B,C*D)
    print(ans)

import sys
import copy
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

Solution (Python):
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())

k = [0] * 2
k[0] = a * b
k[1] = c * d

print(max(k))

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

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

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

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

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

Solution (Python):

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

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())
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):
f=lambda x:max(x[0]*x[1],x[2]*x[3])
print(f(list(map(int,input().split()))))

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

x = A * B
y = C * D

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

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

x = A * B
y = C * D

l = [x,y]

print(max(l))

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

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

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

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

Rectangle1 = A*B
Rectangle2 = C*D

if Rectangle1 > Rectangle2:
    print(Rectangle1)
elif Rectangle1 < Rectangle2:
    print(Rectangle2)
else:
    print(Rectangle1)

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

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

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 = 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):
x = input()

y = x.split(" ")

if int(y[0]) * int(y[1]) > int(y[2]) * int(y[3]):
    print(int(y[0]) * int(y[1]))
elif int(y[0]) * int(y[1]) < int(y[2]) * int(y[3]):
    print(int(y[2]) * int(y[3]))
elif int(y[0]) * int(y[1]) == int(y[2]) * int(y[3]):
    print(int(y[2]) * int(y[3]))

Solution (Python):
a,b,c,d=map(lambda x: int(x), 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 F > E:
  print(F)
else:
  print(E)

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

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

Solution (Python):
import collections
import itertools
import functools
import math

if __name__ == "__main__":
    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):
s = list(map(int,input().split()))

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

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

ans_ab = a * b
ans_cd = c * d

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

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

Solution (Python):
import sys

s = input().split()

s1=1
s2=1

for i in range(0,2):
    s1*=int(s[i])
    s2*=int(s[i+2])

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

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)