peterverebics/CodeNet_Python_118 huggingface dataset:
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]

x0 = 10 ** 9
y0 = 10 ** 9

d = x0 + y0

M = 0
m = 2 * d + 1
for x, y in XY:
    p = x + y + d
    if p > M:
        M = p
    elif p < m:
        m = p

# print(M, m)

print(M - m)
#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate

sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7


N = int(input())
x = [None] * N
y = [None] * N
for i in range(N):
    x[i], y[i] = map(int, input().split())

xmax = x.index(max(x))
xmin = x.index(min(x))
ymax = y.index(max(y))
ymin = y.index(min(y))
ans = 0
for i in [xmin, ymin]:
    for j in [xmax, ymax]:
        ans = max(ans, abs(x[i]-x[j])+abs(y[i]-y[j]))

print(ans)
import sys
input = sys.stdin.readline
N = int(input())
mn = 10 ** 10
mx = -10 ** 10
for _ in range(N):
  x, y = map(int, input().split())
  mn = min(mn, x + y)
  mx = max(mx, x + y)
print(abs(mx - mn))
N = int(input())
z = []
for _ in range(N):
  x, y = list(map(int, input().split()))
  z.append([x, y])

z.sort()
mdct = 0
lx, ly = z[0]
for x, y in z:
  mdct = max(mdct, abs(x-lx) + abs(y-ly))
  
z.sort(key=lambda k: k[1])
lx, ly = z[0]
for x, y in z:
  mdct = max(mdct, abs(x-lx) + abs(y-ly))
print(mdct)
#

import sys
input=sys.stdin.readline

def main():
    N = int(input())
    R = [tuple(map(int, input().split())) for i in range(N)]
    A = sorted(R, key = lambda x: x[0] + x[1])
    print(abs(A[-1][0] - A[0][0]) + abs(A[-1][1] - A[0][1]))
    
    
    
if __name__=="__main__":
    main()
n = int(input())

lst1 = [0]*n
lst2 = [0]*n

M1 = M2 = 0
m1 = m2 = float('inf')

for i in range(n):
  x, y = map(int, input().split())
  d1 = x+y
  d2 = x-y
  M1 = max(M1, d1)
  m1 = min(m1, d1)
  M2 = max(M2, d2)
  m2 = min(m2, d2)

d1 = M1-m1
d2 = M2-m2

print(max(d1, d2))
N = int(input())
a_max = 2
a_min = 2*(10**9)
s_max = 0
s_min = 10**9-1

for i in range(N):
    x,y=map(int,input().split())
    add = x+y
    sub = x-y

    if add > a_max:
        a_max = add
    if add < a_min:
        a_min = add
    if sub > s_max:
        s_max = sub
    if sub < s_max:
        s_max = sub

d_add = a_max - a_min
d_sub = s_max - s_min

print(max(d_add,d_sub))
N=int(input())

P=[list(map(int,input().split())) for _ in range(N)]

L1=[]
L2=[]
L3=[]
L4=[]
for x,y in P:
    L1.append(x+y)
    L2.append(-x+y)
    L3.append(x-y)
    L4.append(-x-y)

L1=sorted(L1)
L2=sorted(L1)
L3=sorted(L1)
L4=sorted(L1)

ans=max(L1[-1]-L1[0],L2[-1]-L2[0],L3[-1]-L3[0],L4[-1]-L4[0])
print(ans)
N = int(input())
x = [0] * N
y = [0] * N
for i in range(N):
    x[i], y[i] = map(int, input().split())


for i in range(N):
  x[i] = x[i] - y[i]
  y[i] = x[i] + y[i]
  
print(max(max(x),max(y))-min(min(x),min(y))-1)
rt = 0
N = int(input())
nums=[]
for _ in range(N):
  nums.append(list(map(int,input().split())))
mn = nums[0][0] + nums[0][1]
mx = nums[0][0] + nums[0][1]
for i in nums:
  mn = min(mn,i[0]+i[1])
  mx = max(mx,i[0]+i[1])
print(mx-mn)
n = int(input())
xy = []
for _ in range(n):
    x,y = map(int,input().split())
    xy.append((x,y))
    
al,be = 1000000000,1000000000
f = [(1,1),(1,-1),(-1,1),(-1,-1)]
ans = 1145141919810364

for k,l in f:
    alfa = al * k
    beta = be * l
    man = []
    for i,j in xy:
        man.append((alfa-i) + (beta-j))
    ans = min(ans,max(man) - min(man))
    
print(ans)
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:tuple(map(int,stdin.readline().split()))

n=int(input())

l=set(tuple([lnii() for i in range(n)]))

x_max=0
x_min=10**10
y_max=0
y_min=10**10

for x,y in l:
#  s=abs(x-y)
  s=x-y
  x_max=max(x_max,s)
  x_min=min(x_min,s)

#  t=abs(x+y)
  t=x+y
  y_max=max(y_max,t)
  y_min=min(y_min,t)

x_ans=x_max-x_min
y_ans=y_max-y_min
print(max(x_ans,y_ans))
N = int(input())
p = [list(map(int, input().split())) for _ in range(N)]
a = []

for i, pos in enumerate(p):
    a.append((sum(pos), i))

a.sort(key=lambda x:x[0])

ans = 0
for i in range(min(1000, N)):
    for j in range(min(1000, N)):
        xi, yi = p[a[i][1]]
        xj, yj = p[a[N - j -1][1]]
    ans = max(ans, abs(xi - xj) + abs(yi - yj))
print(ans)
n = int(input())
a = []
for _ in range(n):
  x, y = map(int, input().split())
  a.append([x,y])

a.sort()
print(abs(a[0][0]-a[n-1][0])+abs(a[0][1]-a[n-1][1]))
n=int(input())
l=[]
for _ in range(n):
    l.append(tuple(map(int,input().split())))
ans=0
for i in range(n-1):
    for j in range(i+1,n):
        can=abs(l[i][0]-l[j][0])+abs(l[i][1]-l[j][0])
        ans=max(ans,can)
print(ans)
pnt=[]
n=int(input())
for i in range(n):
  pnt.append(list(map(int,input().split())))

z=[]
w=[]

for i in pnt:
  z.append(i[0]+i[1])
  w.append(i[0]+i[1])
print(max(max(z)-min(z),max(w)-min(w)))
N = int(input())
X = []
Y = []
for _ in range(N):
    x,y = map(int,input().split())
    X.append(x)
    Y.append(y)

    
sumxy = [x+y for x,y in zip(X,Y)]
sumxy = sorted(sumxy,reverse = False)

ans = sumxy[-1] - sumxy[0]
print(ans)
n = int(input())
p = []
for i in range(n):
  x, y = map(int, input().split())
  p.append([x, y])
  
p.sort(key=lambda x: (x[0]**2 + x[1]**2))

a = []
for i in range(min(n, 1000)):
  for j in range(min(n, 1000)):
    a.append(abs(p[-(i+1)][0] - p[j][0]) + abs(p[-(i+1)][1] - p[j][1]))
    
print(max(a))
N=int(input())
A=[list(map(int, input().split()))  for _ in range(N)]

B=[]
for i,j in A:
    B.append(i+j)

print(max(B)-min(B))
#import random
n=int(input())

pnt=[]
for i in range(n):
  pnt.append(list(map(int,input().split())))
  #pnt.append([random.randint(int(-1e9),int(1e9)),random.randint(int(-1e9),int(1e9))])
pnt.sort(key=lambda x:abs(x[0])+abs(x[1]),reverse=True)
mn=list(reversed(pnt))
mx=0

for i in range(min(n,5000)):
  for j in range(i+1,min(n,5000)):
    mx=max(abs(pnt[i][0]-pnt[j][0])+abs(pnt[i][1]-pnt[j][1]),mx)
    mx=max(abs(pnt[i][0]-mn[j][0])+abs(pnt[i][1]-mn[j][1]),mx)
print(mx)
n = int(input())
p = [list(map(int, input().split())) for _ in range(n)]
q = [[x+y, x-y] for x, y in p]
print(max(max(q)[0] - min(q)[0], max(q, key=lambda x: x[1])[0] - min(q, key=lambda x: x[1])[0]))
#!python3

import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from operator import sub

def resolve():
    it = map(int, sys.stdin.read().split())
    N = next(it)

    M = 10**9+1
    data = [[M, 0], [M, 0]]
    for x, y in zip(it, it):
        for i, x in enumerate([x+y, x-y]):
            for j, f in enumerate([min, max]):
                data[i][j] = f(data[i][j], x)

    print(max(map(lambda x: abs(sub(*x)), data)))



if __name__ == "__main__":
    resolve()
from math import inf
from operator import itemgetter
N=int(input())
points=[]
for _ in range(N):
  a,b=map(int,input().split( ))
  points.append([a,b])
points.sort(key=itemgetter(0))
m1=-inf
m2=inf
m3=-inf
m4=inf
for x,y in points:
  m1=max(m1,x+y)
  m2=min(m2,x+y)
  m3=max(m3,abs(x-y))
  m4=min(m4,abs(x-y))
print(max(m1-m2,m3-m4))
n = int(input())
xy = [list(map(int, input().split())) for i in range(n)]
p = [abs(a[0])+abs(a[1]) for a in xy]
px = max(p)
pn = min(p)
ans =px-pn
print(ans)
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]

min_diff = 10**9
max_diff = 1
min_sum = 2 * 10**9
max_sum = 2

for x,y in XY:
    min_diff = min(abs(x-y), min_diff)
    max_diff = max(abs(x-y), max_diff)
    min_sum = min(x+y, min_sum)
    max_sum = max(x+y, max_sum)

print(max(max_sum-min_sum, max_diff-min_diff))
n = int(input())
xy = [[int(i) for i in input().split()] for j in range(n)]

mi = 10**9
ma = 0

for i in range(n):
    tmp = xy[i][0] + xy[i][1]
    if tmp > ma:
        ma = tmp
    #print(tmp,mi)
    if tmp < mi:
        mi = tmp
        
print(ma-mi)
#print(ma,mi)
N = int(input())
x = [0]*N
y = [0]*N
for i in range(N):
  x[i], y[i] = map(int, input().split())

m1 = 0
mp1 = 0
for i in range(N):
  d = abs(x[i]-x[0])+abs(y[i]-y[0])
  if d>m1:
    m1 = d
    mp1 = i

m2 = 0
mp2 = 0
for i in range(N):
  d = abs(x[i]-x[mp1])+abs(y[i]-y[mp1])
  if d>m2:
    m2 = d
    mp2 = i

ans = 0
for i in range(N):
  ans = max(ans, abs(x[i]-x[mp2])+abs(y[i]-y[mp2]))

print(ans)
n = int(input())
x = [0 for _ in range(n)]
for i in range(n):
    x[i] = list(map(int, input().split()))
    x[i].append(x[i][0]**2 + x[i][1]**2)
x.sort(key = lambda s:s[2])
ans = 0
for i in x:
    ans = max(ans, abs(x[-1][0] - i[0]) + abs(x[-1][1] - i[1]))
print(ans)
N = int(input())
ma = 0
mi = 10**18

xy = [list(map(int,input().split())) for _ in range(N)]
#print(xy)

for i in range(N):
    ma=max(ma,xy[i][0]+xy[i][1])
    mi=min(mi,xy[i][0]+xy[i][1])
print(ma-mi)
N = int(input())

dists = []
while N:
    x, y = map(int, input().split())
    dists.append((x, y, x+y))
    N -= 1

dists.sort(key=lambda x: x[2])
print(abs(dists[0][0] - dists[-1][0] + dists[0][1] - dists[-1][1]))
# Fast IO (be careful about bytestring, not on interactive)

import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

N = int(input())

sumList = []
subList = []

for _ in range(N):
    x,y = map(int,input().split())
    sumList.append(x + y)
    subList.append(x - y)

print(max(max(sumList),max(subList)))
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]

min_diff = 10**9
max_diff = 0
min_sum = 2 * 10**9
max_sum = 2

for x,y in XY:
    min_diff = min(x-y, min_diff)
    max_diff = max(x-y, max_diff)
    min_sum = min(x+y, min_sum)
    max_sum = max(x+y, max_sum)

print(max(max_sum-min_sum, max_diff-min_diff))
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
yx = [[y, x] for x, y in xy]
xy.sort()
yx.sort()
yx = [[x, y] for y, x in yx]

ans = 0
tmp = [xy[0], xy[-1], yx[0], yx[-1]]
for x, y in tmp:
    for x1, y1 in tmp:
        ans = max(ans, abs(x - x1) + abs(y - y1))
print(ans)
import sys

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


def resolve():
    n = int(input())
    XY = [list(map(int, input().split())) for _ in range(n)]

    dist = []
    for i in range(n):
        x, y = XY[i]
        dist.append([x + y, XY[i]])
    dist.sort()
    res = dist[-1][1][0] - dist[0][1][0] + dist[-1][1][1] - dist[0][1][1]
    print(res)


if __name__ == '__main__':
    resolve()
n=int(input())
X=[]
Y=[]
for i in range(n):
    x,y=map(int,input().split())
    X.append(x)
    Y.append(y)
fX=[]
fY=[]
for i in range(n):
    fX.append(X[i]+Y[i])
    fY.append(X[i]-Y[i])
xmax=0
xmin=2**62
ymax=0
ymin=2**62
for i in range(n):
    xmax=max(xmax,fX[i])
    xmin=min(xmin,fX[i])
    ymax=max(ymax,fY[i])
    ymin=min(ymin,fY[i])
print(max(xmax-xmin,ymax-ymin))
n = int(input())
maxx = 0
minn = 2000000001
for i in range(n):
    x,y = map(int,input().split())
    minn = min(minn,x+y)
    maxx = max(maxx,x+y)
print(maxx-minn)
N = int(input())
K = []
for i in range(N):
    x, y = map(int,input().split())
    t = x + y
    if x <= 0:
        t -= 4*abs(x)
    if y <= 0:
        t -= 4*abs(y)
    K.append([t, x, y])

K.sort()
ans = abs(K[0][0] - K[-1][0])
A = [K[0][1]]
for i in range(N-1):
    if K[i][0] == K[i+1][0]:
        A.append(K[i+1][1])
    else:
        ans = max(ans, max(A) - min(A))
        A = [K[i][1]]
print(ans)
n=int(input())
s,p=10**10,10**10
t,q=-1,-1

for i in range(n):
  x,y=map(int,input().split())
  s=min(s,x+y)
  t=max(t,x+y)
  p=min(p,x-y)
  q=max(q,x-y)
  
print(max(t-s,q-p))
n = int(input())
xy = []
for _ in range(n):
    x,y = map(int,input().split())
    xy.append((x,y))
    
al,be = 1000000000,1000000000

man = []
for i,j in xy:
    man.append((al-i) + (be-j))
    
print(max(man) - min(man))
n = int(input())

inf = float('inf')

M1, M2 = 0, 0
m1, m2 = inf, inf

for i in range(n):
  x, y = map(int, input().split())
  d1 = x+y
  d2 = x-y
  M1 = max(M1, d1)
  m1 = min(m1, d1)
  M2 = max(M2, d2)
  m2 = min(m2, d2)

D1 = M1-m1
D2 = M2-m2

print(max(D1, D2))
n=int(input())
l=set()
for _ in range(n):
    x,y=map(int,input().split())
    l.add(x+y)
l=list(l)
print(l[len(l)-1]-l[0])
import math
n=int(input())
a,b=0,0
c,v,b,m=0,0,0,0
for i in range(n):
    x,y=map(int,input().split())
    c=max(x+y,c)
    if i==0:
        v=x+y
    else:
        v=min(x+y,v)

   
    if math.fabs(x-y)>b:
        m=b
    b=max(b,math.fabs(x-y))
print(int(max(c-v, m+b)))
import itertools

n = int(input())
ps = [
    tuple(map(int, input().split()))
    for _ in range(n)
]

xg = sum([p[0] for p in ps]) / len(ps)
yg = sum([p[1] for p in ps]) / len(ps)

maxd = 0
maxp = ps[0]
for p in ps:
    d = abs(xg - p[0]) + abs(yg - p[1])
    if d > maxd:
        maxp = p
        maxd = d

maxd = 0
for p in ps:
    maxd = max(maxd, abs(maxp[0] - p[0]) + abs(maxp[1] - p[1]))
print(maxd)
N = int(input())
xy = [list(map(int,input().split())) for _ in range(N)]
ma = 0
mi = float('inf')
for x,y in xy:
  ma = max(ma,x-y)
  mi = min(mi,x-y)
ans = ma - mi

print(ans)
N = int(input())
z = [0]*N
for n in range(N):
  x,y = map(int, input().split())
  z[n] = abs(x) + abs(y)
print(max(z)-min(z))
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
dist = [None] * N
for i in range(N):
    dist[i] = abs(xy[i][0] - xy[0][0]) + abs(xy[i][1] - xy[0][1])

for j in range(50):
    s = dist.index(max(dist))
    for i in range(N):
        dist[i] = abs(xy[i][0] - xy[s][0]) + abs(xy[i][1] - xy[s][1])
print(max(dist))
N = int(input())

max_li = [0]*N
min_li = [0]*N

for i in range(N):
  x,y = map(int, input().split())
  if x-y >= 0:
    arr = [x+y,x-y]
  else:
    arr = [x+y,y-x]
  
  max_li[i] = max( arr )
  min_li[i] = min( arr )

print( max(max_li)-min(min_li) -2 )
n = int(input())

max1 = 0
min1 = 10 ** 10
max0 = 0
min0 = 10 ** 10

for i in range(n):
    x,y = list(map(int,input().split()))
    k0 = x - y
    k1 = x + y
    if k0 > max0:
        max0 = k0
    if k0 < min0:
        min0 = k0
    if k1 > max1:
        max1 = k1
    if k1 < min1:
        min1 = k1


ans = int(max(max1-min1,max0-min0))

print(ans)
N=int(input())
xy=[tuple(map(int,input().split())) for _ in range(N)]
t=[]
for x,y in xy:
    t.append((x*y,x,y))
t=sorted(t)
xy1=t[0]
xy2=t[-1]
ans=abs(xy1[1]-xy2[1])+abs(xy1[2]-xy2[2])

t=sorted(t,key=lambda x:x[1])
xy1=t[0]
xy2=t[-1]
ans=max(ans,abs(xy1[1]-xy2[1])+abs(xy1[2]-xy2[2]))

t=sorted(t,key=lambda x:x[2])
xy1=t[0]
xy2=t[-1]
ans=max(ans,abs(xy1[1]-xy2[1])+abs(xy1[2]-xy2[2]))

print(ans)
n = int(input())
 
x = []
y = []
distance = []
 
for i in range(n):
  x1, y1 = input().split()
  x1 = int(x1)
  y1 = int(y1)
  x.append(x1)
  y.append(y1)
 
for i in range(len(x)):
  for j in range(len(x)):
    temp = abs(x[i] - x[j]) + abs(y[i] - y[j])
    distance.append(temp)

print(distance)
max = distance[0]
 
for i in range(1,len(distance)-1):
  if distance[i] >= max:
    max = distance[i]
 
print(max)
N = int(input())
Array1 = []
Array2 = []

for i in range(N):
    next_x, next_y = map(int, input().split())
    s = next_x + next_y
    t = next_x - next_y
    Array1.append(s)
    Array2.append(t)

print(max(max(Array1)-min(Array2),max(Array2)-min(Array1)))
N = int(input())
X = []
for _ in range(N):
    x, y = map(int, input().split())
    X.append((x * 2, y * 2))
X = sorted(X, key = lambda x: -x[1])
x0, y0 = X[0]
ans = 0
for x, y in X[1:]:
    ans = max(ans, y0 - y + abs(x - x0))
    if abs(x0 - x) > y0 - y:
        a = abs(x - x0) - (y - y0)
        if x0 > x:
            x0 += a
        else:
            x0 -= a
        y0 += a
print(ans // 2)
n=int(input())
l=[]
max=0
for i in range(n):
  k,kk=map(int, input().split())
  m=l
  while(len(m)>0):
    h=m.pop()
    ma=abs(h[0]-k)+abs(h[1]-kk)
    if ma>max:
      max=ma
  l.append([k,kk])
print(max)
import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
from scipy.spatial import distance


def main():
    N = int(input())
    xy = [list(map(int,input().split())) for i in range(N)]

    xy = np.array(xy)

    print(0)



main()
n=int(input())
r=[list(map(int,input().split())) for _ in range(n)]
a,c,b,d=0,10**10,0,10**10
for i in range(n):
    x,y=r[i]
    a=max(a,abs(x+y))
    c=min(c,abs(x+y))
    b=max(b,abs(x-y))
    d=min(d,abs(x-y))
print(max(a-c,b-d))
n = int(input())

top1= 0
bot1= 10**10
top2= 0
bot2= 10**10
for _ in range(n):
	
	x,y = map(int, input().split(' '))
	tot1= x+y
	tot2= x-y
	if tot1> top1:
		top1= tot1
	if tot1< bot1:
		bot1= tot1
	if tot2>top2:
		top2= tot2
	if tot2<bot2:
		bot2= tot2

print(max(top1-bot1, top2-bot2))
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

n = int(readline())
data = list(map(int,read().split()))

inf = 10**15
axis_p_max = -1 * inf
axis_p_min = inf
axis_m_max = -1 * inf
axis_m_min = inf

it = iter(data)
for x,y in zip(it,it):
    axis_p_max = max(axis_p_max, x+y)
    axis_p_min = min(axis_p_min, x+y)
    axis_m_max = max(axis_m_max, x-y)
    axis_m_min = min(axis_m_max, x-y)

ans = max(axis_p_max-axis_p_min, axis_m_max,axis_m_min)
print(ans)
N = int(input())
i = []
j = []
for k in range(N):
    x, y = map(int, input().split())
    i.append(x+y)
    j.append(-x-y)

print(max(abs(max(i)+max(j)), abs(min(i)+min(j))))
#create date: 2020-09-13 22:30

import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    n = ni()
    amax = 0
    amin = 10**20
    for _ in range(n):
        x, y = na()
        amin = min(amin, x+y)
        amax = max(amax, x+y)
    print(amax-amin)
if __name__ == "__main__":
    main()
n = int(input())
ans = [0]*n
for i in range(n):
    a,b = map(int,input().split())
    ans[i] = a+b

print(abs(max(ans)-min(ans)))
from itertools import combinations
charo=[list(map(int,input().split())) for i in range(int(input(())))]
wan=list(combinations(charo,2))
maximun=0
result=[abs(j[0][0]-j[1][0])+abs(j[0][1]-j[1][1]) for j in wan ]
print(max(result))
n=int(input())
xy=[tuple(map(int, input().split())) for _ in range(n)]

fn=[lambda x:x[0]+x[1],lambda x:x[0]+x[1]]
ans=0
for f in fn:
    xy.sort(key = f)
    ans=max(ans,abs(f(xy[0])-f(xy[-1])))
print(ans)
n = int(input())
maxPlus, minPlus, maxMinus, minMinus = 0, 10**9 , 0, 10**9
for _ in range(n):
    x, y = map(int, input().split())
    maxPlus = max(x + y, maxPlus)
    minPlus = min(x + y, minPlus)
    maxMinus = max(x - y, maxMinus)
    minMinus = min(x - y, minMinus)
print(max(abs(maxPlus - minPlus), abs(maxMinus - minMinus)))
N = int(input())
XY = [list(map(int,input().split())) for _ in range(N)]
for i in range(N):
    XY[i][0], XY[i][1] = XY[i][0]-XY[i][1], XY[i][0]+XY[i][1]

ans = 0
for i in range(2):
    tmp_1 = 0
    tmp_2 = float("inf")
    for j in range(N):
        tmp_1 = max(tmp_1, XY[j][i])
        tmp_2 = min(tmp_2, XY[j][i])
    ans = max(ans, tmp_1-tmp_2)
print(ans)
n = int(input())
zm = -2e10
zn = 30000000000
wm = -2e10
wn = 30000000000
while(n):
  x,y = map(int,input().split())
  zm = max(zm,x+y)
  zn = min(zn,x+y)
  wm = max(wm,x-y)
  wn = min(wn,x-y)
  n-=1
  
print(max(zm-zn,wm,wn))
# author:  Taichicchi
# created: 13.09.2020 21:51:21

import sys


def dist(p1, p2):
    return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])


N = int(input())

ls = []

for i in range(N):
    ls.append(list(map(int, input().split())))

ls.sort(key=lambda x: (x[0], x[1]))

ans = 0

for i in range(1, N):
    ans = max(ans, dist(ls[0], ls[i]))

ls.sort(key=lambda x: (x[1], x[0]))

for i in range(1, N):
    ans = max(ans, dist(ls[0], ls[i]))

print(ans)
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

n=int(input())

l=[lnii() for i in range(n)]

if len(l)==1:
  print(0)
  exit()

x_max=0
x_min=10**10
y_max=0
y_min=10**10

for x,y in l:
  s=x-y
  x_max=max(x_max,s)
  x_min=min(x_min,s)

  t=x+y
  y_max=max(y_max,t)
  y_min=min(y_min,t)

x_ans=x_max-x_min
y_ans=y_max-y_min
print(max(x_ans,y_ans))
import numpy as np
N = int(input())
max_z = 0
min_z = np.inf
max_w = 0
min_w = np.inf
for _ in range(N):
    x, y = map(int, input().split())
    z = x + y
    w = x - y
    max_z = max(max_z, z)
    min_z = min(min_z, z)
    max_w = max(max_w, w)
    min_w = min(min_w, w)
print(max(max_z-min_z, max_w-min_w))
n=int(input())
l=[]
max=0
for i in range(n):
  k,kk=map(int, input().split())
  m=list(l)
  print(l)
  while(len(m)>0):
    h=m.pop()
    ma=abs(h[0]-k)+abs(h[1]-kk)
    if ma>max:
      max=ma
  l.append([k,kk])
print(max)
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
num = 10*9 + 5
maxmax = 0
minmin = num
_min = num
_max = 0
for x, y in xy:
    if x + y > maxmax:
        maxmax = x + y
    if x - y > _max:
        _max = x - y
    if x + y < minmin:
        minmin = x + y
    if y - x < _min:
        _min = y - x
result = maxmax - minmin if maxmax - minmin > _max - _min else _max - _min
print(result)
N = int(input())
i = []
j = []
for k in range(N):
    x, y = map(int, input().split())
    i.append(x+y)
    j.append(-x-y)

p = max(i)

del j[i.index(max(i))]

m = max(j)

print(p+m)
n=int(input())
ab=[list(map(int,input().split())) for _ in range(n)]
a = 0
b = 0
l = [0]*n

for i in range(n):
    a += ab[i][0]
    b += ab[i][1]

a = a/n
b = b/n

for j in range(n):
    l[j] = abs(ab[j][0]-a) + abs(ab[j][1]-b)

c = l.index(max(l))
l[c] = 0
d = l.index(max(l))

e = abs(ab[c][0]-ab[d][0]) + abs(ab[c][1]-ab[d][1])
print(e)
N = int(input())
def f0(x,y):
    return x-y

def f1(x,y):
    return x+y



max0 = 0
max1 = 0
min0 = 10**10
min1 = 10**10

for i in range(N):
    x,y = map(int, input().split())

    a = f0(x,y)
    b = f1(x,y)

    max0 = max(a, max0)
    min0 = min(a, min0)
    max1 = max(b, max1)
    min1 = min(b, min1)



res = max(max0-min0, max1-min1)
if res < 0:
    res = 0
print(res)
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]

sum_xy = sorted([x+y for x, y in xy])
print(sum_xy[-1] - sum_xy[0])
data = input().split()
time = int(data[0]) /  int(data[2])
if int(data[1]) >= time :
    print("Yes")
else:
    print("No")
D,T,S = list(map(int,input().split()))

if D / S <= T:
  print('Yes')
else:
  print('No')
D, S, T = map(int, input().split())
if S*T >= D:
  print("Yes")
else:
  print("No")
d,t,s=map(int, input().split())
if t*s>=d:
    print('Yes')
else: print('No')
d,t,s=map(int,input().split())
if d <=s*t:
  print("Yes")
else:
  print("No")
d, t, s = map(int, input().split())
if d/s <= t:
  print("Yes")
else:
  print("No")
requestMap = list(map(float, input().split()))

D = requestMap[0]
T = requestMap[1]
S = requestMap[2]

dist = S * T

if dist >= D:
  print("Yes")
else:
  print("No")
def tc(arr):
    tn = arr[0]/arr[2]
    return "Yes" if tn<=arr[1] else "No"





u = list(map(int, input().split()))
print(tc(u))
d,t,s = map(int,input().split())
if s*t - d >=0:
    print("Yes")
else:
    print("No")
d,t,s=map(int,input().split())
if d<=t*s:
    print("Yes")
else:
    print("No")
D, T, S = map(int, input().split())

print('Yes' if D <= T*S else 'No')
import sys


def _ia(): return map(int, sys.stdin.readline().strip().split())


def main():
    d, t, s = _ia()
    return "Yes" if t * s >= d else "No"


if __name__ == "__main__":
    print(main())
d, t, s = map(int, input().split())

if d / s <= t:
    print('Yes')
else:
    print('No')
a = input().split()
dist = int(a[0])
time = int(a[1])
speed = int(a[2])
if(speed * time < dist):
	print("No")
else:
	print("Yes")
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    D, T, S = [int(x) for x in input().split()]
    if T * S >= D:
        print("Yes")
    else:
        print("No")

    

if __name__ == '__main__':
    main()
x, y, z = [int(a) for a in input().split()]
if y*z>=x:
  print("Yes")
else:
  print("No")
d,t,s = map(int, input().split())
if d / s <= t:
    print("Yes")
else:
    print("No")
d, t, x = map(int, input().split())
if x*t >= d:
    print("Yes")
else:
    print("No")
d,t,s=map(int,input().split())
if d-t*s<=0 :
  print('Yes')
else :
  print('No')
d,t,s = map(int,input().split())
print('Yes' if s*t>=d else 'No')
D,T,S=map(int,input().split())
if S*T >= D:
    print("Yes")
else:
    print("No")
strin = input()
D, T, S = int(strin.split(" ")[0]), int(strin.split(" ")[1]), int(strin.split(" ")[2])
if (D / S) <= T:
    print("Yes")
else:
    print("No")
import sys

def main():

	D,T,S = map(int, input().split())
	
	if D/S <= T:
		print("Yes")
	else:
		print("No")

if __name__ == "__main__":
    main()