class Tree(n: Int) {
    val lst = run {
        var t = 2
        while (t < n) t *= 2
        t
    }
    val t = IntArray(2 * lst)
    val upd = IntArray(2 * lst)

    private fun push(v: Int) {
        update(2 * v, upd[v])
        update(2 * v + 1, upd[v])
        upd[v] = 0
    }

    private fun add(v: Int, l: Int, r: Int, L: Int, R: Int, d: Int) {
        if (r <= L || R <= l) return
        if (L <= l && r <= R) {
            update(v, d)
            return
        }
        push(v)
        add(2 * v, l, (l + r) / 2, L, R, d)
        add(2 * v + 1, (l + r) / 2, r, L, R, d)
        t[v] = minOf(t[2 * v], t[2 * v + 1])
    }

    private fun update(v: Int, d: Int) {
        upd[v] += d
        t[v] += d
    }

    private fun get(v: Int, l: Int, r: Int, L: Int, R: Int): Int {
        if (r <= L || R <= l) return Int.MAX_VALUE
        if (L <= l && r <= R) {
            return t[v]
        }
        push(v)
        return minOf(
            get(2 * v, l, (l + r) / 2, L, R),
            get(2 * v + 1, (l + r) / 2, r, L, R,)
        )
    }

    fun add(l: Int, r: Int, d: Int) = add(1, 0, lst, l, r, d)
    fun get(l: Int, r: Int) = get(1, 0, lst, l, r)

    private fun debug(v: Int, add:Int, l:Int, r:Int, L:Int, R:Int, to: MutableList<Int>) {
        if (r <= L || R <= l) return
        if (l == r - 1) {
            to.add(add + t[v]);
            return
        }
        debug(2 * v, add + upd[v], l, (l + r) / 2, L, R, to)
        debug(2 * v + 1, add + upd[v], (l + r) / 2, r, L, R, to)
    }
    fun debug(L:Int, R:Int) = mutableListOf<Int>().apply { debug(1, 0, 0, lst, L, R, this) }
}

fun main() {
    System.setIn(System.`in`.buffered())
    val (n, q, m) = readInts()
    val x = readInts()
    val p = IntArray(n) { -1 }
    val t = readInts()
    val qa = IntArray(q)
    val qb = IntArray(q)
    for (i in 0 until q) {
        val (a, b) = readInts()
        qa[i] = a - 1
        qb[i] = b - 1
    }
    var ptr = 0
    for (i in 0 until n) {
        while (ptr < i && x[ptr] + m < x[i]) {
            ptr += 1
        }
        if (ptr == i) {
            p[i] = -1
        } else {
            p[i] = ptr
        }
    }
    val g = List(n) { mutableListOf<Int>() }
    for (i in 0 until n) {
        if (p[i] != -1) {
            g[p[i]].add(i)
        }
    }
    val lf = IntArray(n) { -1 }
    val rg = IntArray(n) { -1 }
    var timer = 0
    for (i in 0 until n) {
       if (lf[i] == -1) {
           require(p[i] == -1)
           DeepRecursiveFunction {
               lf[it] = timer++
               for (v in g[it]) {
                   callRecursive(v)
               }
               rg[it] = timer
           }(i)
       }
    }

    val tree = Tree(n)

    for (i in 0 until n) {
        tree.add(lf[i], lf[i] + 1, t[i])
        tree.add(lf[i], rg[i], if (p[i] == -1) Int.MAX_VALUE / 2 else 1)
    }

    val qs = List(n) { mutableListOf<Int>() }
    for (i in 0 until q) {
        qs[qb[i]].add(i)
    }
    val ans = IntArray(q) { -1 }

    var okptr = 0

    for (i in 0 until n) {
        while (okptr < n && x[okptr] <= x[i] +  m) {
            tree.add(lf[okptr], rg[okptr], if (p[okptr] == -1) -Int.MAX_VALUE / 2 else -1)
            okptr += 1
        }
        val jumped = minOf(t[i] + 1, tree.get(0, n) + 2)
        for (qid in qs[i]) {
            val from = qa[qid]
            ans[qid] = minOf(jumped, tree.get(lf[from], lf[from] + 1) - t[from] + 1)
        }
    }
    println(ans.joinToString(" "))
}

private fun readInt() = readln().toInt()
private fun readLongs() = readStrings().map { it.toLong() }
private fun readStrings() = readln().split(" ")
private fun readInts() = readStrings().map { it.toInt() }