import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.PrintWriter
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.sqrt

fun main(args: Array<String>) {

    // IO Templates
    val br = BufferedReader(InputStreamReader(System.`in`))
    val out = PrintWriter(System.out)

    val n = br.readLine()!!.toInt()

    val points = mutableListOf<MyVector>()

    for (i in 1..n) {
        val (x, y) = br.readLine()!!.split(' ').map { it.toInt() }
        points.add(MyVector(x, y))
    }

    var ru = points.first()
    var lu = points.first()
    var ld = points.first()
    var rd = points.first()

    for (i in 1 until n) {
        val point = points[i]
        if ((point.x - ru.x) + (point.y - ru.y) > 0) ru = point
        if ((-point.x + lu.x) + (point.y - lu.y) > 0) lu = point
        if ((-point.x + ld.x) + (-point.y + ld.y) > 0) ld = point
        if ((point.x - rd.x) + (-point.y + rd.y) > 0) rd = point
    }

    out.println(
        max(
            abs(ru.x - ld.x) + abs(ru.y - ld.y),
            abs(lu.x - rd.x) + abs(lu.y - rd.y)
        )
    )

    out.flush()
}

data class MyVector(
    var x: Long,
    var y: Long
) {

    constructor(x: Int, y: Int) : this(x = x.toLong(), y = y.toLong())

    fun plus(x: Long, y: Long) {
        this.x += x
        this.y += y
    }

    operator fun plus(v: MyVector) {
        plus(v.x, v.y)
    }

    fun minus(x: Long, y: Long) {
        this.x -= x
        this.y -= y
    }

    operator fun minus(v: MyVector) {
        minus(v.x, v.y)
    }

    fun scalarTimes(m: Long) {
        x *= m
        y *= m
    }

    operator fun times(v: MyVector): Long = x * v.x + y * v.y

    fun squareMagnitude(): Long = this.times(this)

    fun magnitude(): Double = sqrt(squareMagnitude().toDouble())
}
