#include <algorithm>
#include <string.h>
#include <fstream>
#include <vector>

#define maxN 751
#define maxK 16
#define maxB 32769

#define INF 0x7fffffff

using namespace std;

ifstream in;
ofstream out;

vector <int> g[maxN];

int v[maxK];
int dist[maxN];

int gc[maxN][maxN];
int gd[maxN][maxN];

int cost[maxK][maxK][maxK];
int D[maxB][maxK];

int N,K;

inline bool cmp(const int &a,const int &b)
{
    return dist[a]>dist[b];
}

inline void Dij(int nod,int num)
{
    int h[maxN];
    for(int i=1;i<=N;++i) dist[i]=INF;
    memset(h,0,sizeof(h));

    h[0]=1;
    h[1]=nod;
    dist[nod]=0;

    while(h[0])
    {
        nod=h[1];
        pop_heap(h+1,h+h[0]+1,cmp);
        --h[0];

        for(vector <int>::iterator it=g[nod].begin();it!=g[nod].end();++it)
            if(dist[*it]>dist[nod]+(num+1)*gc[nod][*it]&&num<=gd[nod][*it])
            {
                dist[*it]=dist[nod]+(num+1)*gc[nod][*it];
                h[++h[0]]=*it;
                push_heap(h+1,h+h[0]+1,cmp);
            }
    }
}

int main()
{
    int M,x,y;

    in.open("gather.in");

    in>>K>>N>>M;

    v[0]=1;
    for(int i=1;i<=K;++i) in>>v[i];

    while(M--)
    {
        in>>x>>y;
        in>>gc[x][y]>>gd[x][y];

        gc[y][x]=gc[x][y];
        gd[y][x]=gd[x][y];

        g[x].push_back(y);
        g[y].push_back(x);
    }

    in.close();

    memset(cost,-1,sizeof(cost));

    for(int i=0;i<K;++i)
        for(int j=0;j<=K;++j)
        {
            Dij(v[j],i);

            for(int k=1;k<=K;++k)
                if(dist[v[k]]!=INF)
                    cost[i][j][k]=dist[v[k]];
        }

    int MAX=(1<<K);

    for(int i=0;i<MAX;++i)
        for(int j=0;j<=K;++j)
            D[i][j]=INF;

    D[0][0]=0;
    for(int gr=0;gr<MAX;++gr)
    {
        int num=0;
        for(int x=gr;x;x>>=1)
            if(x&1) ++num;
        for(int nod=0;nod<=K;++nod)
            if(D[gr][nod]!=INF)
                for(int i=1;i<=K;++i)
                    if((gr&(1<<(i-1)))==0&&D[gr+(1<<(i-1))][i]>D[gr][nod]+cost[num][nod][i]&&cost[num][nod][i]>=0)
                        D[gr+(1<<(i-1))][i]=D[gr][nod]+cost[num][nod][i];
    }

    int sol=INF;
    --MAX;
    for(int i=1;i<=K;++i)
        if(sol>D[MAX][i]) sol=D[MAX][i];

    out.open("gather.out");

    out<<sol<<'\n';

    out.close();

    return 0;
}