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



Sample input:
3 5 2 7


Sample output:
15

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# # Make IO faster
# import sys
# input = sys.stdin.readline

# # get single (or) multiple str
# X = input()

# # get single int
# N = int(input())
# # get multiple int (e.g., 2)
# X, Y = map(int, input().split())
# # get multiple int (e.g., 2) for N lines
# XY = [list(map(int, input().split())) for _ in range(N)]

# from IPython import embed; embed(); exit();

# 全部入り
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]))

Submission status: Accepted

Solution code:
a, b, c, d = list(map(lambda n: int(n), input().split(" ")))
print(max([a * b, c * d]))

Submission status: Accepted

Solution code:
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])

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def resolve():
    A, B, C, D = list(map(int, input().split()))
    area1 = A * B
    area2 = C * D
    print(max([area1, area2]))

resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d = map(int, open(0).read().split())
print(max(a*b,c*d))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
import math
#a, d = map(int,input().split())
#N = int(input())
#S = input()
ans = 0

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d=[int(i) for i in input().split()]
e=a*b
f=c*d
print(max(e,f))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
if A*B > C*D:
    print(A*B)
elif A*B <= C*D:
    print(C*D)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
AB = a*b
CD = c*d
if AB<CD:
  print(CD)
else:
  print(AB)

Submission status: Accepted

Solution code:


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n=int(input())
a,b,c,d=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

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

Submission status: Accepted

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

Submission status: Accepted

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

ans = a*b, c*d

print(max(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

f = a * b 
s = c * d

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = list(map(int, input().split()))
a = l[0]
b = l[1]
c = l[2]
d = l[3]

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

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import numpy as np
import random
from decimal import Decimal
import itertools
import re
import bisect
from collections import deque, Counter
from functools import lru_cache

sys.setrecursionlimit(10**9)
INF = 10**13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')
def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]
def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]
MOD = 1000000007

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b, c, d = M()
x = a*b
y = c*d
print(max(x, y))

Submission status: Accepted

Solution code:

lst = input().split()


for i in range(len(lst)):
   lst[i] = int(lst[i])


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

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


print(areas[1])

Submission status: Accepted

Solution code:
#入力
lst = input().split()

#整数値化
for i in range(len(lst)):
   lst[i] = int(lst[i])

#各面積
area1 = lst[0] * lst[1]
area2 = lst[2] * lst[3]

#リストに格納してソート
areas = [area1, area2]
areas.sort()

#出力
print(areas[1])

Submission status: Accepted

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

# print(a,b,c,d)

rectangle_x = a * b
rectangle_y = c * d

if rectangle_x > rectangle_y:
    print(rectangle_x)
elif rectangle_x < rectangle_y:
    print(rectangle_y)
else:
    print(rectangle_x)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C,D = map(int,input().split())
#print(A,B,C,D)

ans1 = A*B
ans2 = C*D

if ans1 == ans2:
  print(ans1)
elif ans1 > ans2:
  print(ans1)
else:
  print(ans2)

Submission status: Accepted

Solution code:
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Rect1 = int(A*B)

Rect2 = int(C*D)

if (Rect1 > Rect2):
    print(Rect1)

elif (Rect1 < Rect2):
    print(Rect2)

else:
    print(Rect1)

Submission status: Accepted

Solution code:
def actual(A, B, C, D):
    area1 = A * B
    area2 = C * D

    if area1 >= area2:
        return area1

    return area2

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def INT():
    return int(input())

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

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

A, B, C, D = MI()

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split());print([a*b,c*d][a*b<c*d])

Submission status: Accepted

Solution code:
A,B,C,D = map(int,input().split())
x = A*B
y = C*D

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
A,B,C,D = map(int,input().split())
if A > 10000 or B > 10000 or C > 10000 or D > 10000:
    sys.exit()
if A * B >= C * D:
    print(A*B)
    sys.exit()
if A * B <= C*D:
    print(C*D)
    sys.exit()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
i = [int(s) for s in input().split()]
a = i[0] * i[1]
at = i[2] * i[3]
if a < at:
    print(at)
else:
    print(a)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
x = a * b
y = c * d

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
ns=input()

nsl=ns.split(' ')

nl=[]

for i in range(4):
  nl.append(int(nsl[i]))

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

Submission status: Accepted

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

s_1 = a * b
s_2 = c * d

if s_1 == s_2:
  print(s_2)
else:
  print(max(s_1, s_2))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
m = a * b
n = c * d

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C,D = (int(x) for x in input().split())
area1 = A*B
area2 = C*D
if(area1 > area2):
    print(area1)
elif(area1 < area2):
    print(area2)
else:
    print(area1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()

from collections import defaultdict, deque, Counter
from sys import exit
import heapq
import math
from fractions import gcd
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7

from itertools import permutations
from math import factorial, hypot

#############
# Main Code #
#############

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
rec1 = int(a[0]* a[1])
rec2 = int(a[2] * a[3])

if rec1 > rec2:
    result = rec1
elif rec2 > rec1:
    result = rec2
else:
    result = rec1

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a,b,c,d = map(int, input().split())

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
A,B,C,D = map(int,input().split())	
if A*B>C*D:
    print(A*B)
elif A*B<=C*D:
    print(C*D)

Submission status: Accepted

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

ab = a * b
cd = c * d

if ab >= cd:
    print(ab)
elif ab < cd:
    print(cd)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = input().split()
a = int(x[0])
b = int(x[1])
c = int(x[2])
d = int(x[3])
a_b = a*b
c_d = c*d
if a_b > c_d:
  print(a_b)
else:
  print(c_d)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Python3 (3.4.3)
import sys
input = sys.stdin.readline

# -------------------------------------------------------------
# function
# -------------------------------------------------------------


# -------------------------------------------------------------
# main
# -------------------------------------------------------------
A,B,C,D = map(int,input().split())
 
print(max(A*B,C*D))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, c, d = mi()
    print(max(a*b, c*d))


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
def LI(): return list(map(int,stdin.readline().rstrip().split()))

tmp = LI()

a,b,c,d = [tmp.pop(0) for i in range(4)]

s1 = a*b
s2 = c*d

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

x = a * b
y = c * d

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
length=list(map(int,input().split()))
men1 =length[0]*length[1]
men2 =length[2]*length[3]

if men1>=men2:
    print(men1)
else:
    print(men2)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

def Main(A, B, C, D):
    return max(A*B, C*D)

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

Submission status: Accepted

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