#include<fstream>
#include<algorithm>
#include<queue>
#include<vector>
#define maxn 50010
const long inf = 0x3f3f3f3f;
using namespace std;

struct muchie{
    int y,c,d;
};

vector<bool> Detinut;
vector<pair<int,int> > A;
vector<muchie> V[maxn];
vector<int> Viz;
vector<bool> Test;
vector<pair<int,bool> > P;

queue<int> Q;
int D,N,M;
int nrD;
vector<long> C;
int det[maxn];

ifstream f("gather.in");
ofstream g("gather.out");

bool myFct(pair<int,int> a,pair<int,int> b){
    return a.second<b.second;
}

int parcurgere(int S,int detinuti){
    int atins=0;
    Q.push(S);
    Viz[S]=1;
    while(!Q.empty()){
        int nod=Q.front();
        Q.pop();
        for(vector<muchie>::iterator it=V[nod].begin();it!=V[nod].end();it++){
            //g<<nod<<' '<<it->y<<Viz[it->y]<<'\n';
            if(Viz[it->y]==0&&it->d>=detinuti){
                Q.push(it->y);
                Viz[it->y]=1;
                if(Detinut[it->y])
                    atins++;
            }
        }
    }
    return atins;
}

int bellman(int S,int detinuti,int F,int val){
    for(int i=1;i<=N;i++)
        C[i]=inf;
        C[S]=val;
    for(int i=0;i<=N;i++)
        Test[i]=false;
    Q.push(S);
    Test[S]=true;
    while(!Q.empty()){
        int nod=Q.front();
        if(nod==F)
            return C[nod];
        Q.pop();
        Test[nod]=false;
        for(vector< muchie >::iterator it=V[nod].begin();it!=V[nod].end();++it){
            if(C[it->y]>C[nod]+it->c&&detinuti<=it->d&&P[it->y].first<=P[F].first){
                C[it->y]=C[nod]+(detinuti+1)*it->c;
                if(Detinut[it->y])
                    detinuti++;
                P[it->y].second=true;
                if(!Test[it->y])
                    Q.push(it->y),Test[it->y]=true;
            }
        }
    }
    return 0;
}

void citire(){
    muchie m;
    int x,y;
    f>>D>>N>>M;
    Detinut.resize(N+1);
    P.resize(N+1);
    A.resize(D+1);
    Viz.resize(N+1);
    C.resize(N+1);
    Test.resize(N+1);
    for(int i=0;i<D;i++){
        f>>x;
        Detinut[x]=true;
        A[i].first=x;
    }
    for(int i=1;i<=M;i++){
        f>>x>>y>>m.c>>m.d;
        m.y=y;
        V[x].push_back(m);
        m.y=x;
        V[y].push_back(m);
    }
}

int main(){
    citire();
    for(int i=0;i<D;i++)
        for(int j=1;j<D;j++){
            Viz.clear();
            Viz.resize(N+1);
            A[i].second+=parcurgere(A[i].first,j);
            P[A[i].first].first+=A[i].second;
        }

    sort(A.begin(),A.end()-1,myFct);
    int s=0;
    s+=bellman(1,0,A[0].first,0);
    for(int i=0;i<D;i++){
        if(!P[A[i].first].second)
            s+=bellman(A[i].first,A[i].second-1,A[i+1].first,s);
    }

    g<<s;

    g<<'\n';
    g.close();
    return 0;
}