import sys
from collections import deque

def main():
    input = sys.stdin.read().split()
    idx = 0
    N = int(input[idx]); idx +=1
    M = int(input[idx]); idx +=1
    K = int(input[idx]); idx +=1
    T = int(input[idx]); idx +=1

    magic = []
    for _ in range(K):
        A = int(input[idx]) - 1; idx +=1
        B = int(input[idx]) - 1; idx +=1
        C = int(input[idx]); idx +=1
        D = int(input[idx]); idx +=1
        magic.append( (A, B, C, D) )

    # Precompute distance from start (1,1) [0-based]
    dist_from_start = [[float('inf')] * M for _ in range(N)]
    q = deque()
    dist_from_start[0][0] = 0
    q.append( (0, 0) )
    dx = [-1, 1, 0, 0]
    dy = [0, 0, -1, 1]

    while q:
        x, y = q.popleft()
        for d in range(4):
            nx = x + dx[d]
            ny = y + dy[d]
            if 0 <= nx < N and 0 <= ny < M:
                if dist_from_start[nx][ny] > dist_from_start[x][y] + 1:
                    dist_from_start[nx][ny] = dist_from_start[x][y] + 1
                    q.append( (nx, ny) )

    # Precompute distance to end (N, M) [0-based]
    dist_to_end = [[float('inf')] * M for _ in range(N)]
    dist_to_end[N-1][M-1] = 0
    q = deque()
    q.append( (N-1, M-1) )

    while q:
        x, y = q.popleft()
        for d in range(4):
            nx = x + dx[d]
            ny = y + dy[d]
            if 0 <= nx < N and 0 <= ny < M:
                if dist_to_end[nx][ny] > dist_to_end[x][y] + 1:
                    dist_to_end[nx][ny] = dist_to_end[x][y] + 1
                    q.append( (nx, ny) )

    S_min = dist_from_start[N-1][M-1]
    if S_min <= T:
        print(0)
        return

    min_fatigue = float('inf')

    for (A, B, C, D) in magic:
        if dist_from_start[A][B] == float('inf') or dist_to_end[A][B] == float('inf'):
            continue
        if C < 2:
            continue

        S_ab = dist_from_start[A][B] + dist_to_end[A][B]
        denominator = C - 2

        if denominator <= 0:
            continue

        if S_ab > T:
            numerator = S_ab - T
            required_k = (numerator + denominator - 1) // denominator
            candidate_time = S_ab + required_k * (2 - C)
            if candidate_time <= T:
                fatigue = D * required_k
                if fatigue < min_fatigue:
                    min_fatigue = fatigue

    if min_fatigue != float('inf'):
        print(min_fatigue)
    else:
        print(-1)

if __name__ == "__main__":
    main()