import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.io.PrintWriter
import java.util.*

data class Point(val x: Long, val y: Long)

fun orientation(p: Point, q:Point, r:Point):Long {
    val x = area(p,q,r)
    if (x > 0) return 1
    if (x < 0) return -1
    return 0
}

fun area(p: Point, q:Point, r:Point): Long {
    return (p.y - q.y) * (q.x - r.x) - (q.y - r.y) * (p.x - q.x)
}

fun absArea(p:Point, q:Point, r:Point): Long {
    return Math.abs(area(p, q, r))
}

fun dist(p1 :Point, p2:Point): Long {
    return Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
}

fun convexHull(points: Array<Point>): List<Point> {
    val n = points.count()
    var min = Point(Long.MAX_VALUE, Long.MAX_VALUE)
    var ind = -1
    for (i in 0 until n) {
        if (min.y > points[i].y) {
            min = points[i]
            ind = i
        } else if (min.y == points[i].y && min.x > points[i].x) {
            min = points[i]
            ind = i
        }
    }
    points[ind] = points[0]
    points[0] = min
    fun compare(o1: Point, o2:Point): Int {
        val o = orientation(min, o1, o2)
        if (o == 0L) {
            val d = dist(o1, min) - dist(o2, min)
            return if (d > 0) 1 else if (d < 0) -1 else 0
        }
        if (o == 1L) return 1
        return -1
    }
    points.sortWith(Comparator { o1, o2 -> compare(o1, o2)})
    val st = Stack<Point>()
    st.push(points[0])
    var k = 1
    while (k < n - 1) {
        if (orientation(points[0], points[k], points[k + 1]) != 0L) break
        k++
    }
    st.push(points[k])
    for (i in k + 1 until n) {
        var top = st.pop()
        while (orientation(st.peek(), top, points[i]) >= 0) {
            top = st.pop()
        }
        st.push(top)
        st.push(points[i])
    }
    val hull = mutableListOf<Point>()
    for (i in 0 until st.count()) {
        hull.add(st[i])
    }
    return hull
}

fun rotatingCaliper(points: Array<Point>): Long {
    val convexHull = convexHull(points)
    var n = convexHull.count()
    val hull = Array(n) { Point(0, 0) }
    n = 0
    while (n < convexHull.count()) {
        hull[n] = convexHull[n++]
    }
    if (n == 1) return 0
    if (n == 2) return dist(hull[0], hull[1])
    var k = 1
    while (absArea(hull[n-1], hull[0], hull[(k+1)%n]) > absArea(hull[n-1],hull[0],hull[k])) {
        k++
    }
    var res = 0L
    var i = 0
    var j = k
    while (i <= k && j < n) {
        res = maxOf(res, dist(hull[i], hull[j]))
        while (j < n && absArea(hull[i],
                        hull[(i + 1) % n],
                        hull[(j + 1) % n])
                > absArea(hull[i],
                        hull[(i + 1) % n],
                        hull[j])) {
            res = maxOf(res, dist(hull[i], hull[(j+1)%n]))
            j++
        }
        i++
    }
    return res
}

fun PrintWriter.solve(sc: FastScanner) {
    val n = sc.nextInt()
    val p = Array(n) { Point(sc.nextLong(), sc.nextLong()) }
    println(rotatingCaliper(p))
}

fun main() {
    val writer = PrintWriter(System.out, false)
    writer.solve(FastScanner(System.`in`))
    writer.flush()
}

class FastScanner(s: InputStream) {
    private var st = StringTokenizer("")
    private val br = BufferedReader(InputStreamReader(s))

    fun next(): String {
        while (!st.hasMoreTokens()) st = StringTokenizer(br.readLine())

        return st.nextToken()
    }

    fun nextInt() = next().toInt()
    fun nextLong() = next().toLong()
    fun nextLine() = br.readLine()
    fun nextDouble() = next().toDouble()
    fun ready() = br.ready()
}
