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

struct edge{int node,cst,cap;};
int n,m,K,nh,sol,ok;
int h[maxn],pos[maxn],d[maxn],p[20];
vector<edge> l[maxn],lp[20];
int s[mask][20];

void read()
{
    int x,y,cost,capacity;
    scanf("%d%d%d",&K,&n,&m);

    for(int i=1;i<=K;i++)
    {
        scanf("%d",&p[i]);
        if(p[i]==1) ok=i;
    }
    if(ok) swap(p[ok],p[K]);

    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&x,&y,&cost,&capacity);
        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;

    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;

    s[cm][k]=inf;
    if(cm==(1<<(k-1))) return;

    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));
         if(s[nm][lp[k][i].node]==-1) det(nm,lp[k][i].node,nr-1);
         s[cm][k]=min(s[cm][k],s[nm][lp[k][i].node]+(nr)*lp[k][i].cst);
     }
}

void solve()
{
    for(int i=0;i<(1<<K);i++)
     for(int j=1;j<=K;j++)
      s[i][j]=-1;

    if(!ok)
    {
         dijkstra(1,0);
         for(int i=1;i<=K;i++) s[1<<(i-1)][i]=d[p[i]];
    }
    else s[1<<(K-1)][K]=0;

    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;
}