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

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


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

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

rec1 = a * b
rec2 = c * d

if rec1 >= rec2:
    print(rec1)
else:
    print(rec2)

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

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    a, b, c, d = i_map()
    
    print(a*b if a*b >= c*d else c*d)

if __name__ == '__main__':
    main()

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

obj1 = a*b
obj2 = c*d

if obj1 < obj2:
    ans = obj2
elif obj2 < obj1:
    ans = obj1
else:
    ans = obj1

print(ans)

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




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

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

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

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

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



area_ab = A * B
area_cd = C * D

if area_ab > area_cd:
    print(area_ab)
else:
    print(area_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())

ab = A * B
cd = C * D

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

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

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

def answer(A: int, B: int, C: int, D: int) -> int:
    return max(A * B, C * D)

print(answer(A, B, C, D))

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

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

rec1 = a * b
rec2 = c * d

if rec1 == rec2:
    print(rec1)
else:
    print(max(rec1, rec2))

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

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

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

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

Solution (Python):

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

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

area = [A * B, C * D]

print(max(area))

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

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

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

Solution (Python):
S_list = iter(list(map(int,input().split())))
area = list()
for x,y in zip(S_list ,S_list):
    area.append(x*y)
print(max(area))

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

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

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

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

Solution (Python):



square = list(map(int, input().split()))

result = [square[0] * square[1], square[2] * square[3]]
print(max(result))

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

area1 = A * B
area2 = C * D

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

Solution (Python):
a,b,c,d=map(int,input().split())
e=[]
f=a*b
g=c*d
e.append(f)
e.append(g)
if(f==g):
    print(f)
else:
    print(max(e))

Solution (Python):
'''
問題：
    二つの長方形があります。
    一つ目の長方形は、縦の辺の長さが A、横の辺の長さが B です。
    二つ目の長方形は、縦の辺の長さが C、横の辺の長さが D です。

    この二つの長方形のうち、面積の大きい方の面積を出力してください。 なお、二つの長方形の面積が等しい時は、その面積を出力してください。
'''

'''
制約：
    入力は全て整数である
    1 ≦ A ≦ 10000
    1 ≦ B ≦ 10000
    1 ≦ C ≦ 10000
    1 ≦ D ≦ 10000
'''


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

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

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

Solution (Python):


def atc_052a(input_value: str) -> int:
    A, B, C, D = map(int, input_value.split(" "))
    return max(A * B, C * D)

input_value = input()
print(atc_052a(input_value))

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

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

Solution (Python):

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


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

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

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

Solution (Python):



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


if A * B >= C * D:
    answer = A * B
else:
    answer = C * D

print(answer)

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

Solution (Python):
vertical1, horizontal1, vertical2, horizontal2 = map(int, input().split())
area1 = vertical1 * horizontal1
area2 = vertical2 * horizontal2
if area1 < area2:
    print(area2)
else:
    print(area1)

Solution (Python):
vertical1, horizontal1, vertical2, horizontal2 = map(int, input().split())
if vertical1 * horizontal1 < vertical2 * horizontal2:
    print(vertical2 * horizontal2)
else:
    print(vertical1 * horizontal1)

Solution (Python):


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

area = [A * B, C * D]

print(max(area))

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

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

area = [a*b,c*d]

print(max(area))

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

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

areaAB = A * B
areaCD = C * D

if areaAB == areaCD:
    result = areaAB
elif areaAB > areaCD:
    result = areaAB
else:
    result = areaCD

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

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







area_ab = A * B
area_cd = C * D

if area_ab > area_cd:
    print(area_ab)
else:
    print(area_cd)

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

Solution (Python):



a,b,c,d=(int(x) for x in input().split())



menseki1 = a * b
menseki2 = c * d

if menseki1 > menseki2:
    print(menseki1)

elif menseki1 < menseki2:
    print(menseki2)

else :
    print(menseki1)

Solution (Python):

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

if (1<=A&A<=10**4)&(1<=B&B<=10**4)&(1<=C&C<=10**4)&(1<=D&D<=10**4):
    if S1>S2:
        print(S1)
    elif S1<=S2:
        print(S2)

Solution (Python):
rectangle1_scale1, rectangle1_scale2, rectangle2_scale1, rectangle2_scale2 = map(int, input().split())

big_rectangle_area = max(rectangle1_scale1 * rectangle1_scale2, rectangle2_scale1 * rectangle2_scale2)

print(big_rectangle_area)

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

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


if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    A, B, C, D = map(int, readline().split())

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


if __name__ == '__main__':
    main()

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

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

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

x = A * B
y = C * D
list = [x, y]
print(max(list))

Solution (Python):
height_a, length_a, height_b, length_b = map(int, input().split())

rectangle_a = height_a * length_a
rectangle_b = height_b * length_b

if rectangle_a == rectangle_b:
    print(rectangle_a)
elif rectangle_a > rectangle_b:
    print(rectangle_a)
elif rectangle_b > rectangle_a:
    print(rectangle_b)

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

a = A * B
b = C * D
c = [a, b]
print(max(c))

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

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

if b-c>0:
  print(b)

else:
  print(c)

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 = [int(i) for i in 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())

one = a * b
two = c * d

print(*max([one],[two]))

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

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

a = A * B
b = C * D

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

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

def main():
    t = list(map(int, input().split()))
    print(max(t[0]*t[1],t[2]*t[3]))

if __name__ == '__main__':
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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

area1 = a*b
area2 = c*d

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

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

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

Solution (Python):

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

Solution (Python):
a, b, c, d = map(int, input().split())
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 = (int(T) for T 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())

s1 = a * b
s2 = c * d

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

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

Solution (Python):
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 = input().split(' ')
if int(a[0]) * int(a[1]) > int(a[2]) * int(a[3]):
  print(int(a[0]) * int(a[1]))
else:
  print(int(a[2]) * int(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):
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=(int(x) for x in input().split())
e= a * b
f= c * d
if e < f : 
    print( f )
elif e > f :
    print( e )
elif e == f :
    print( e )

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

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

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

t1 = a*b
t2 = c*d
print(max(t1, t2))

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

Solution (Python):

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

area_1 = a*b
area_2 = c*d

if area_1 <= area_2:
  ans = area_2
else:
  ans = area_1

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

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

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

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

















import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
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(lambda n: int(n), input().split(" ")))
print(max([a * b, c * d]))

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

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

resolve()

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

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

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

A,B,C,D = I()
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):

import math



ans = 0

l = list(map(int,input().split()))

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

Solution (Python):


def main():

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

    area = []

    area.append(A * B)
    area.append(C * D)

    ans = max(area)

    print(ans)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    A, B, C, D = map(int, readline().split())

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

    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    A, B, C, D = map(int, readline().split())

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

    return


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())

A,B,C,D = MI()
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 = list(map(int, input().split()))

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    A, B, C, D = LI()

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

if __name__ == '__main__':
    resolve()

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

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

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

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

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

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

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

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

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

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

Solution (Python):


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


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


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

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 = (int(x) for x in input().split())
if A*B > C*D:
  print (A*B)
else:
  print (C*D)

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

ans = a*b, c*d

print(max(ans))

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

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

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

f = a * b 
s = c * d

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

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

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):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

Solution (Python):
l = list(map(int, input().split()))
a = l[0]
b = l[1]
c = l[2]
d = l[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):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

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


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

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


if __name__ == '__main__':
    main()

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