-- https://github.com/minoki/my-atcoder-solutions
{-# LANGUAGE BangPatterns #-}
import Data.Char (isSpace)
import Data.List (unfoldr)
import Control.Monad
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as U
import qualified Data.ByteString.Char8 as BS
import Data.Array
import Data.Array.ST

data Path = WithoutRefuel !Int -- 移動距離
          | WithRefuel !Int !Int !Int -- 給油回数、最初に給油するまでの移動距離、最後に給油してからの移動距離
          | Unreachable
          deriving (Eq, Ord, Show)

addPath :: Int -> Path -> Path -> Path
addPath l (WithoutRefuel a) (WithoutRefuel b) | a + b <= l = WithoutRefuel (a + b)
                                              | otherwise = WithRefuel 1 a b
addPath l (WithRefuel n a b) (WithRefuel m a' b') | b + a' <= l = WithRefuel (n + m) a b'
                                                  | otherwise = WithRefuel (n + m + 1) a b'
addPath l (WithoutRefuel a) (WithRefuel m a' b') | a + a' <= l = WithRefuel m (a + a') b'
                                                 | otherwise = WithRefuel (m + 1) a b'
addPath l (WithRefuel n a b) (WithoutRefuel a')  | b + a' <= l = WithRefuel n a (b + a')
                                                 | otherwise = WithRefuel (n + 1) a a'
addPath l Unreachable _ = Unreachable
addPath l _ Unreachable = Unreachable

checkAssoc l x y z = (addPath l x (addPath l y z), addPath l (addPath l x y) z)

-- 最短距離の (Int, Int) は (給油の回数, 最後に給油してからの移動距離（0以上L以下）, 最初に給油するまでの移動距離)
warshallFloyd :: Int -> V.Vector [(Int, Int)] -> Array (Int, Int) Path
warshallFloyd !l !graph = runSTArray $ do
  let n = V.length graph
  arr <- newArray ((0,0),(n-1,n-1)) Unreachable
  forM_ [0..n-1] $ \a -> do
    forM_ (graph V.! a) $ \(b,c) -> do
      writeArray arr (a,b) (WithoutRefuel c)
      writeArray arr (b,a) (WithoutRefuel c)
  forM_ [0..n-1] $ \a -> do
    writeArray arr (a,a) (WithoutRefuel 0)
  forM_ [0..n-1] $ \k -> do
    forM_ [0..n-1] $ \i -> do
      forM_ [0..n-1] $ \j -> do
        a_ij <- readArray arr (i,j)
        a_ik <- readArray arr (i,k)
        a_kj <- readArray arr (k,j)
        writeArray arr (i,j) $! min a_ij (addPath l a_ik a_kj)
  return arr

main = do
  [n,m,l] <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
  edges <- U.replicateM m $ do
    [a,b,c] <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
    return (a-1,b-1,c)
  let edges' = U.filter (\(a,b,c) -> c <= l) edges
  let graph :: V.Vector [(Int, Int)]
      graph = V.create $ do
        g <- VM.replicate n []
        U.forM_ edges' $ \(a,b,c) -> do
          VM.modify g ((b,c) :) a
        return g
  let w = warshallFloyd l graph
  q <- readLn
  queries <- U.replicateM q $ do
    [s,t] <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
    return (s,t)
  U.forM_ queries $ \(s,t) -> do
    print $ case w ! (s-1,t-1) of
              WithoutRefuel _ -> 0
              WithRefuel n _ _ -> n
              Unreachable -> -1
