#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
using namespace std;

//int cur;
//vector<int> N;
//vector<int> K;
//bool recursive(int n) {
//    if (n >= N[cur])
//        return false;
//    for (int i = 1; i <= K[i]; i++) {
//        recursive(i);
//    }
//}

int main() {
    int N,C,V;
    cin >> N;
    cin >> C;
    cin >> V;
    vector<int> S(V);
    vector<int> T(V);
    vector<int> Y(V);
    vector<int> M(V);
    for (int i = 0; i < V; i++) cin >> S[i];
    for (int i = 0; i < V; i++) cin >> T[i];
    for (int i = 0; i < V; i++) cin >> Y[i];
    for (int i = 0; i < V; i++) cin >> M[i];
    
    int dp[2][51][51];
    for (int j = 0; j <= N; j++)
        for (int i = 0; i <= N; i++) { dp[0][j][i] = dp[1][j][i] = 101010; }
    
    for (int i = 0; i < V; i++) { dp[0][S[i]][T[i]] = M[i]; dp[1][S[i]][T[i]] = Y[i]; }
    
    for (int k = 1; k <= N; k++)
        for (int j = 1; j <= N; j++)
            for (int i = 1; i <= N; i++) {
                if (dp[0][i][j]<dp[0][i][k]+dp[0][k][j]) {
//                    dp[0][i][j] = dp[0][i][j];
                }
                else {
                    if (dp[1][i][k]+dp[1][k][j] <= C) {
                        dp[0][i][j] = dp[0][i][k]+dp[0][k][j];
                        dp[1][i][j] = dp[1][i][k]+dp[1][k][j];
                    }
                }
//                dp[0][i][j] = min(dp[0][i][j], dp[0][i][k]+dp[0][k][j]);
            }
    
    cout << ((dp[0][1][N] == 101010)?-1:dp[0][1][N]) << endl;
    
//    N.resize(P);
//    K.resize(P);
//    for (int i = 0; i < P; i++) cin >> N[i] >> K[i];
//    for (int i = 0; i < P; i++) {
////        cur = i;
////        vector<vector<bool>> dp(N[i]);
////        for (int j = 0; j < N[i]; j++) dp[i] = true;
////        for (int j = 1; j <= K[i]; j++) dp[j] = true;
////        recursive(0);
//        
//        if ((N[i]-1)%(K[i]+1))
//            cout << "Win" << endl;
//        else
//            cout << "Lose" << endl;
//    }
    
//    sort(W.begin(),W.end());
//    int ret = 0;
//    while (L>0&&ret<N) L -= W[ret++];
//    if (L<0) ret--;
//    cout << ret << endl;
    return 0;
}