Problem:
Score : 500 points

Problem Statement

There are N cities numbered 1 to N, connected by M railroads.

You are now at City 1, with 10^{100} gold coins and S silver coins in your pocket.

The i-th railroad connects City U_i and City V_i bidirectionally, and a one-way trip costs A_i silver coins and takes B_i minutes.
You cannot use gold coins to pay the fare.

There is an exchange counter in each city. At the exchange counter in City i, you can get C_i silver coins for 1 gold coin.
The transaction takes D_i minutes for each gold coin you give.
You can exchange any number of gold coins at each exchange counter.

For each t=2, ..., N, find the minimum time needed to travel from City 1 to City t. You can ignore the time spent waiting for trains.

Constraints

2 \leq N \leq 50

N-1 \leq M \leq 100

0 \leq S \leq 10^9

1 \leq A_i \leq 50

1 \leq B_i,C_i,D_i \leq 10^9

1 \leq U_i < V_i \leq N

There is no pair i, j(i \neq j) such that (U_i,V_i)=(U_j,V_j).

Each city t=2,...,N can be reached from City 1 with some number of railroads.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M S
U_1 V_1 A_1 B_1
:
U_M V_M A_M B_M
C_1 D_1
:
C_N D_N

Output

For each t=2, ..., N in this order, print a line containing the minimum time needed to travel from City 1 to City t.

Sample Input 1

3 2 1
1 2 1 2
1 3 2 4
1 11
1 2
2 5

Sample Output 1

2
14

The railway network in this input is shown in the figure below.

In this figure, each city is labeled as follows:

The first line: the ID number i of the city (i for City i)

The second line: C_i / D_i

Similarly, each railroad is labeled as follows:

The first line: the ID number i of the railroad (i for the i-th railroad in input)

The second line: A_i / B_i

You can travel from City 1 to City 2 in 2 minutes, as follows:

Use the 1-st railroad to move from City 1 to City 2 in 2 minutes.

You can travel from City 1 to City 3 in 14 minutes, as follows:

Use the 1-st railroad to move from City 1 to City 2 in 2 minutes.

At the exchange counter in City 2, exchange 3 gold coins for 3 silver coins in 6 minutes.

Use the 1-st railroad to move from City 2 to City 1 in 2 minutes.

Use the 2-nd railroad to move from City 1 to City 3 in 4 minutes.

Sample Input 2

4 4 1
1 2 1 5
1 3 4 4
2 4 2 2
3 4 1 1
3 1
3 1
5 2
6 4

Sample Output 2

5
5
7

The railway network in this input is shown in the figure below:

You can travel from City 1 to City 4 in 7 minutes, as follows:

At the exchange counter in City 1, exchange 2 gold coins for 6 silver coins in 2 minutes.

Use the 2-nd railroad to move from City 1 to City 3 in 4 minutes.

Use the 4-th railroad to move from City 3 to City 4 in 1 minutes.

Sample Input 3

6 5 1
1 2 1 1
1 3 2 1
2 4 5 1
3 5 11 1
1 6 50 1
1 10000
1 3000
1 700
1 100
1 1
100 1

Sample Output 3

1
9003
14606
16510
16576

The railway network in this input is shown in the figure below:

You can travel from City 1 to City 6 in 16576 minutes, as follows:

Use the 1-st railroad to move from City 1 to City 2 in 1 minute.

At the exchange counter in City 2, exchange 3 gold coins for 3 silver coins in 9000 minutes.

Use the 1-st railroad to move from City 2 to City 1 in 1 minute.

Use the 2-nd railroad to move from City 1 to City 3 in 1 minute.

At the exchange counter in City 3, exchange 8 gold coins for 8 silver coins in 5600 minutes.

Use the 2-nd railroad to move from City 3 to City 1 in 1 minute.

Use the 1-st railroad to move from City 1 to City 2 in 1 minute.

Use the 3-rd railroad to move from City 2 to City 4 in 1 minute.

At the exchange counter in City 4, exchange 19 gold coins for 19 silver coins in 1900 minutes.

Use the 3-rd railroad to move from City 4 to City 2 in 1 minute.

Use the 1-st railroad to move from City 2 to City 1 in 1 minute.

Use the 2-nd railroad to move from City 1 to City 3 in 1 minute.

Use the 4-th railroad to move from City 3 to City 5 in 1 minute.

At the exchange counter in City 5, exchange 63 gold coins for 63 silver coins in 63 minutes.

Use the 4-th railroad to move from City 5 to City 3 in 1 minute.

Use the 2-nd railroad to move from City 3 to City 1 in 1 minute.

Use the 5-th railroad to move from City 1 to City 6 in 1 minute.

Sample Input 4

4 6 1000000000
1 2 50 1
1 3 50 5
1 4 50 7
2 3 50 2
2 4 50 4
3 4 50 3
10 2
4 4
5 5
7 7

Sample Output 4

1
3
5

The railway network in this input is shown in the figure below:

Sample Input 5

2 1 0
1 2 1 1
1 1000000000
1 1

Sample Output 5

1000000001

The railway network in this input is shown in the figure below:

You can travel from City 1 to City 2 in 1000000001 minutes, as follows:

At the exchange counter in City 1, exchange 1 gold coin for 1 silver coin in 1000000000 minutes.

Use the 1-st railroad to move from City 1 to City 2 in 1 minute.

Solution in Haskell (GHC 8.8.3) (judge verdict: Runtime Error)

{-# LANGUAGE BangPatterns #-}
import           Control.Exception           (assert)
import           Control.Monad
import           Control.Monad.Primitive
import qualified Control.Monad.ST            as ST
import qualified Data.Array.IO               as IO
import qualified Data.Array.ST               as ST
import qualified Data.Array.Unboxed          as A
import           Data.Bits
import qualified Data.ByteString.Char8       as BS
import           Data.Char
import           Data.Foldable
import           Data.List
import           Data.Maybe
import qualified Data.Sequence               as Seq
import qualified Data.Set                    as Set
import qualified Data.Vector                 as VB
import qualified Data.Vector.Mutable         as VBM
import qualified Data.Vector.Unboxed         as V
import qualified Data.Vector.Unboxed.Mutable as VM
import           Debug.Trace

readInt = fst . fromJust . BS.readInt
readIntList = map readInt . BS.words
getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine
getIntVec n = V.unfoldrN n (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine

readInteger = fst . fromJust . BS.readInteger
readIntegerList = map readInteger . BS.words
getInteger = readInteger <$> BS.getLine
getIntegerList = readIntegerList <$> BS.getLine

inf :: Int
inf = 10^18

-- (node, dist)
type Graph_dijk = VB.Vector (V.Vector (Int, Int))

dijkstra :: Int -> Graph_dijk -> Int -> IO (V.Vector Int)
dijkstra s g numV = do

  let inf = 10^18 :: Int
  d <- VM.new numV
  VM.set d inf
  VM.write d s 0

  -- tuple represent (min distance, node id)
  let set = Set.singleton (0, s)

      loop :: Set.Set (Int, Int) -> IO ()
      loop set | Set.null set = return ()
               | otherwise = do
                   let ((mdist, v), set') = Set.deleteFindMin set
                       edges = g VB.! v
                   d_v <- VM.read d v
                   if d_v < mdist
                     then loop set'
                     else do set'' <- loop2 v edges 0 set'
                             loop set''

      loop2 :: Int -> V.Vector (Int, Int) -> Int -> Set.Set (Int, Int)
            -> IO (Set.Set (Int, Int))
      loop2 v edges j set
        | j >= V.length edges = return set
        | otherwise = do
            let e = edges V.! j
                v_to = fst e
                cost = snd e
            d_v <- VM.read d v
            d_to <- VM.read d v_to
            let cond = d_to > d_v + cost
                set' = if cond
                       then (d_v + cost, v_to) `Set.insert` set
                       else set
            when cond $ VM.write d v_to (d_v + cost)
            loop2 v edges (j+1) set'

  loop set
  V.freeze d

main = do
  let max_cities = 50
      max_silvers = 50 * 50
      fnode city silver = silver * 50 + city
      max_nodes = fnode max_cities (max_silvers+1)


  g <- VBM.new (max_nodes+1)
  VBM.set g (V.empty)

  [n, m, s0] <- getIntList

  replicateM_ m $ do
    [u, v, a, b] <- getIntList
    forM_ [a..max_silvers] $ \s -> do
      let n_frm1 = fnode (u-1) s
          n_to1  = fnode (v-1) (s-a)
          n_frm2 = fnode (v-1) s
          n_to2  = fnode (u-1) (s-a)
      t1 <- VBM.read g n_frm1
      VBM.write g n_frm1 (t1 `V.snoc` (n_to1, b))
      t2 <- VBM.read g n_frm2
      VBM.write g n_frm2 (t2 `V.snoc` (n_to2, b))

  forM_ [0..(n-1)] $ \i -> do
    [c, d] <- getIntList
    forM_ [0..(max_silvers - 1)] $ \s -> do
      let n_frm = fnode i s
          n_to  = fnode i (min max_silvers (s+c))
      t <- VBM.read g n_frm
      VBM.write g n_frm (t `V.snoc` (n_to, d))

  g' <- VB.freeze g

  let n_start = fnode 0 s0
  d <- dijkstra n_start g' max_nodes

  let solve i j res | j > max_silvers = res
                    | otherwise =
                        let x = d V.! fnode i j
                        in solve i (j+1) (min x res)

  forM_ [1..(n-1)] $ \i -> do
    let a = solve i 0 inf
    print a