#include<stdio.h>
#include<algorithm>
#include<vector>
#define pb push_back
#define mp make_pair
#define maxn 755
#define mask 1<<16
#define maxb 8192
#define inf 0x3f3f3f3f
using namespace std;

#define NXT if(++pc==maxb) fread(buff,1,maxb,stdin),pc=0
struct edge{int node;int cst;int cap;};
int n,m,K,nh;
int h[maxn],pos[maxn],p[20];
vector<edge> l[maxn],lp[20];
int d[maxn],s[mask][20],ok[mask][20],sol;
char buff[maxb];
int pc=0;

int get()
{
    int nr=0;
    while(buff[pc]<'0' || buff[pc]>'9') NXT;
    while(buff[pc]>='0' && buff[pc]<='9')
    {
        nr=nr*10+buff[pc]-'0';
        NXT;
    }
    return nr;
}

void read()
{
    int x,y,cost,capacity;
    K=get(); n=get(); m=get();

    for(int i=1;i<=K;i++) p[i]=get();
    for(int i=1;i<=m;i++)
    {
        x=get(); y=get(); cost=get(); capacity=get();
        l[x].pb({y,cost,capacity});
        l[y].pb({x,cost,capacity});
    }
}

void swap(int i,int j)
{
    int aux;
    aux=h[i]; h[i]=h[j]; h[j]=aux;
    pos[h[i]]=i; pos[h[j]]=j;
}

void heap_up(int k)
{
    if(k==1) return;
    int i=k/2;
    if(d[h[k]]<d[h[i]]) {swap(i,k); heap_up(i);}
}

void heap_dw(int k)
{
    int i=2*k;
    if(i<=nh)
    {
        if(i+1<=nh && d[h[i+1]]<d[h[i]]) i++;
        if(d[h[i]]<d[h[k]]) {swap(i,k); heap_dw(i);}
    }
}

int extract()
{
    swap(1,nh--);
    pos[h[nh+1]]=0;
    return h[nh+1];
}

void dijkstra(int S,int D)
{
    int k;
    for(int i=1;i<=n;i++) h[i]=i,pos[i]=i,d[i]=inf;
    d[S]=0; nh=n; swap(1,pos[S]);

    while(nh)
    {
        k=extract();
        heap_dw(1);
        for(unsigned int i=0;i<l[k].size();i++)
         if(pos[l[k][i].node] && l[k][i].cap>=D && d[k]+l[k][i].cst<d[l[k][i].node] )
         {
             d[l[k][i].node]=d[k]+l[k][i].cst;
             heap_up(pos[l[k][i].node]);
         }
    }
}

void build_graph()
{
    for(int i=1;i<=K;i++)
     for(int j=1;j<=K;j++)
     {
         dijkstra(p[i],j);
         for(int k=1;k<=K;k++)
          if(k!=i && d[p[k]]!=inf)
            lp[k].pb({i,d[p[k]],j});
     }
}

void det(int cm,int k,int nr)
{
    int nm,nk;
    int Min=inf;

    for(unsigned int i=0;i<lp[k].size();i++)
     if( ((cm>>(lp[k][i].node-1))&1) && lp[k][i].cap>=nr-1 )
     {
         nm=cm^(1<<(k-1)); nk=lp[k][i].node;
         if(!ok[nm][nk]) det(nm,nk,nr-1);
         Min=min(Min,s[nm][nk]+nr*lp[k][i].cst);
     }
    s[cm][k]=Min; ok[cm][k]=1;
}

void solve()
{
    dijkstra(1,-1);
    for(int i=1;i<=K;i++) s[1<<(i-1)][i]=d[p[i]],ok[1<<(i-1)][i]=1;

    sol=inf;
    for(int i=1;i<=K;i++)
     det((1<<K)-1,i,K),sol=min(sol,s[(1<<K)-1][i]);
}

int main()
{
    freopen("gather.in","r",stdin);
    freopen("gather.out","w",stdout);

    read();
    build_graph();
    solve();
    printf("%d",sol);


    fclose(stdin);
    fclose(stdout);
    return 0;
}