Buggy python submission (verdict: Runtime Error):
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        # Adjacency matrices recording distances for each company
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        stations = list(range(n))
        
        # Adjacency matrix recording for the Dijkstra's algorithm
        adj_matrix = [[inf] * n for i in range(n)]
        
        for mat in adj_matrices:
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            # Warshall–Floyd Algorithm
            for k in range(n):
                sc = stations.copy()
                del sc[k]
                for x, y in combinations(sc, 2):
                    d = min(mat[x][y], mat[x][k] + mat[k][y])
                    mat[x][y] = d
                    mat[y][x] = d
                    
                    # Fare calculation
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    if fare < adj_matrix[x][y]:
                        adj_matrix[x][y] = fare
                        adj_matrix[y][x] = fare
        
        # Dijkstra's algorithm
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for v, f in enumerate(adj_matrix[u]):
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()


Fixed submission:
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        # Adjacency matrices recording distances for each company
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        # Adjacency matrix recording fare for the Dijkstra's algorithm
        adj_matrix = [[inf] * n for i in range(n)]
        
        for mat in adj_matrices:
            # Warshall–Floyd Algorithm
            for k in range(n):
                for x, y in combinations(range(n), 2):
                    d1 = mat[x][y]
                    d2 = mat[x][k] + mat[k][y]
                    if d2 < d1:
                        mat[x][y] = d2
                        mat[y][x] = d2
            
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            # Fare calculation
            for x, y in combinations(range(n), 2):
                d = mat[x][y]
                if d != inf:
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    if fare < adj_matrix[x][y]:
                        adj_matrix[x][y] = fare
                        adj_matrix[y][x] = fare
        
        # Dijkstra's algorithm
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for v, f in enumerate(adj_matrix[u]):
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()

Buggy python submission (verdict: Runtime Error):
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        # Adjacency matrices recording distances for each company
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        stations = list(range(n))
        
        # Adjacency list for the Dijkstra's algorithm
        adj_list = [[] for i in range(n)]
        
        for mat in adj_matrices:
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            # Warshall–Floyd Algorithm
            for k in range(n):
                sc = stations.copy()
                del sc[k]
                for x, y in combinations(sc, 2):
                    d = min(mat[x][y], mat[x][k] + mat[k][y])
                    mat[x][y] = d
                    mat[y][x] = d
                    
                    # Fare calculation
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    adj_list[x].append((fare, y))
                    adj_list[y].append((fare, x))
        
        # Dijkstra's algorithm
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for f, v in adj_list[u]:
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()


Fixed submission:
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        # Adjacency matrices recording distances for each company
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        # Adjacency matrix recording fare for the Dijkstra's algorithm
        adj_matrix = [[inf] * n for i in range(n)]
        
        for mat in adj_matrices:
            # Warshall–Floyd Algorithm
            for k in range(n):
                for x, y in combinations(range(n), 2):
                    d1 = mat[x][y]
                    d2 = mat[x][k] + mat[k][y]
                    if d2 < d1:
                        mat[x][y] = d2
                        mat[y][x] = d2
            
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            # Fare calculation
            for x, y in combinations(range(n), 2):
                d = mat[x][y]
                if d != inf:
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    if fare < adj_matrix[x][y]:
                        adj_matrix[x][y] = fare
                        adj_matrix[y][x] = fare
        
        # Dijkstra's algorithm
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for v, f in enumerate(adj_matrix[u]):
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()

Buggy python submission (verdict: Runtime Error):
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        # Adjacency matrices recording distances for each company
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        # Adjacency matrix recording fare for the Dijkstra's algorithm
        adj_matrix = [[inf] * n for i in range(n)]
        
        for mat in adj_matrices:
            # Warshall–Floyd Algorithm
            for k in range(n):
                for x, y in combinations(range(n), 2):
                    d = min(mat[x][y], mat[x][k] + mat[k][y])
                    if d != inf:
                        mat[x][y] = d
                        mat[y][x] = d
            
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            # Fare calculation
            for x, y in combinations(range(n), 2):
                d = mat[x][y]
                if d != inf:
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    if fare < adj_matrix[x][y]:
                        adj_matrix[x][y] = fare
                        adj_matrix[y][x] = fare
        
        # Dijkstra's algorithm
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for v, f in enumerate(adj_matrix[u]):
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()


Fixed submission:
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        # Adjacency matrices recording distances for each company
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        # Adjacency matrix recording fare for the Dijkstra's algorithm
        adj_matrix = [[inf] * n for i in range(n)]
        
        for mat in adj_matrices:
            # Warshall–Floyd Algorithm
            for k in range(n):
                for x, y in combinations(range(n), 2):
                    d1 = mat[x][y]
                    d2 = mat[x][k] + mat[k][y]
                    if d2 < d1:
                        mat[x][y] = d2
                        mat[y][x] = d2
            
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            # Fare calculation
            for x, y in combinations(range(n), 2):
                d = mat[x][y]
                if d != inf:
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    if fare < adj_matrix[x][y]:
                        adj_matrix[x][y] = fare
                        adj_matrix[y][x] = fare
        
        # Dijkstra's algorithm
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for v, f in enumerate(adj_matrix[u]):
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()