import java.io.IOException
import java.io.PrintWriter



fun main(args : Array<String>) {
    val fs = FastScanner()
    val N = fs.nextInt()
    val M = fs.nextInt()
    val L = fs.nextLong()

    // graph
    val INF = 10000000000L
    val d = Array(N) { LongArray(N) { INF }}
    val dist = Array(N) { LongArray(N) { INF }}
    for (i in 0 until N) {
        d[i][i] = 0L
        dist[i][i] = 0L
    }
    for (i in 0 until M) {
        val a = fs.nextInt() - 1
        val b = fs.nextInt() - 1
        val c = fs.nextLong()
        d[a][b] = c
        d[b][a] = c
    }

    // worital
    for (k in 0 until N) {
        for (i in 0 until N) {
            for (j in 0 until N) {
                if (d[i][k] + d[k][j] < d[i][j]) {
                    d[i][j] = d[i][k] + d[k][j]
                }
            }
        }
    }
    // WHY?????????
    for (i in 0 until N) {
        for (j in 0 until N) {
            if (i != j) {
                if (d[i][j] <= L) {
                    dist[i][j] = Math.min(1, dist[i][j])
                }
            }
        }
    }

    for (k in 0 until N) {
        for (i in 0 until N) {
            for (j in 0 until N) {
                if (dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j]
                }
            }
        }
    }

    val printWriter = PrintWriter(System.out)

    val Q = fs.nextInt()
    for (i in 0 until Q) {
        val s = fs.nextInt() - 1
        val t = fs.nextInt() - 1
        val dis = dist[s][t]
        if (dis == INF) {
            printWriter.printf("%d\n", -1)
        } else {
            printWriter.printf("%d\n", dis - 1)
        }
    }
    printWriter.close()
}

internal class FastScanner {
    private val `in` = System.`in`
    private val buffer = ByteArray(1024)
    private var ptr = 0
    private var buflen = 0
    private fun hasNextByte(): Boolean {
        if (ptr < buflen) {
            return true
        } else {
            ptr = 0
            try {
                buflen = `in`.read(buffer)
            } catch (e: IOException) {
                e.printStackTrace()
            }

            if (buflen <= 0) {
                return false
            }
        }
        return true
    }

    private fun readByte(): Int {
        return if (hasNextByte()) buffer[ptr++].toInt() else -1
    }

    private fun isPrintableChar(c: Int): Boolean {
        return 33 <= c && c <= 126
    }

    private fun skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr].toInt())) ptr++
    }

    operator fun hasNext(): Boolean {
        skipUnprintable()
        return hasNextByte()
    }

    operator fun next(): String {
        if (!hasNext()) return ""
        val sb = StringBuilder()
        var b = readByte()
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b)
            b = readByte()
        }
        return sb.toString()
    }

    fun nextLong(): Long {
        if (!hasNext()) return -1
        var n: Long = 0
        var minus = false
        var b = readByte()
        if (b == '-'.toInt()) {
            minus = true
            b = readByte()
        }
        if (b < '0'.toInt() || '9'.toInt() < b) {
            throw NumberFormatException()
        }
        while (true) {
            if ('0'.toInt() <= b && b <= '9'.toInt()) {
                n *= 10
                n += (b - '0'.toInt()).toLong()
            } else return if (b == -1 || !isPrintableChar(b)) {
                if (minus) -n else n
            } else {
                throw NumberFormatException()
            }
            b = readByte()
        }
    }

    fun nextInt(): Int {
        val set = hashSetOf<Char>()
        set.add('3')
        set.clear()

        if (!hasNext()) return -1
        var n: Int = 0
        var minus = false
        var b = readByte()
        if (b == '-'.toInt()) {
            minus = true
            b = readByte()
        }
        if (b < '0'.toInt() || '9'.toInt() < b) {
            throw NumberFormatException()
        }
        while (true) {
            if ('0'.toInt() <= b && b <= '9'.toInt()) {
                n *= 10
                n += (b - '0'.toInt()).toInt()
            } else return if (b == -1 || !isPrintableChar(b)) {
                if (minus) -n else n
            } else {
                throw NumberFormatException()
            }
            b = readByte()
        }
    }
}

Measured memory_bytes: 74864