#include <fstream>
#include <queue>
#include <vector>
using namespace std;

#define nod first.first
#define cost first.second
#define nbr second

#define val first
#define key second

typedef pair<int,int> Pair;
typedef pair<Pair,int> Triple;

const int Nmax = 755;
const int Mmax = 1255;
const int Kmax = 17;
const int oo = 0x3f3f3f3f;

int N,M,K,act;
int Nodes[Kmax];

vector< Triple > Leg[Nmax];

int D[1<<Kmax][Kmax];
int Dist[Kmax][Kmax][Kmax];

int Marked[Nmax],Co;
int Cost[Nmax];

ifstream F("gather.in");
ofstream G("gather.out");

priority_queue< Pair , vector< Pair > , greater< Pair > > Heap;

int main()
{
	F>>K>>N>>M;
	Nodes[0]=1;
	for (int i=1;i<=K;++i)
		F>>Nodes[i];
	for (int i=1;i<=M;++i)
	{
		int x,y,c,n; 
		F>>x>>y>>c>>n;
		Leg[x].push_back( make_pair( make_pair( y , c ) , n ) );
		Leg[y].push_back( make_pair( make_pair( x , c ) , n ) );
	}
	
	for (int i=0;i<=K;++i)
		for (int j=0;j<= i==0 ? 0 : K ;++j)
		{
			int Start = Nodes[i];
			Heap.push( make_pair(0,Start) );
			
			while ( Co < N )
			{
				while ( Marked[ Heap.top().key ] )
					Heap.pop();
				
				int Nod = Heap.top().key ;
				Marked[ Nod ] = 1, ++Co;
				Cost[ Nod ] = Heap.top().val;
				
				Heap.pop();
				
				for ( vector<Triple>::iterator it=Leg[Nod].begin();it!=Leg[Nod].end();++it )
					if ( !Marked[ it->nod ] && it->nbr >= j )
						Heap.push( make_pair( it->cost + Cost[ Nod ] , it->nod ) );
			}
			
			for (int k=1;k<=K;++k)
				Dist[i][k][j] = Cost[ Nodes[k] ];
			for (int k=1;k<=N;++k) Marked[k]=Cost[k]=0;
			
			Co=0;
			
			while ( Heap.size() ) Heap.pop();
		}
	
	for (int i=1;i<( 1<<K );++i)
	{
		int det=0;
		for(int x=i;x;x>>=1)
            if (x&1) ++det;
		for ( int j=1,jj=1;j<=i;j<<=1,++jj)
			if ( j&i )
			{
				D[i][jj]=oo;
				int Act = i-j;
				if ( Act == 0 )
					D[i][jj]= Nodes[jj] == 1 ? 0 : Dist[0][jj][0];
				else
					for ( int k=1,kk=1;k<=Act;k<<=1,++kk)
						if ( k & Act )
							D[i][jj]= min ( D[i][jj] , Dist[kk][jj][det-1] * det + D[Act][kk] );
			}
	}
	
	int Sol=oo;
	for (int i=1;i<=K;++i)
		Sol=min(Sol,D[(1<<K)-1][i]);
	
	G<<Sol<<'\n';
}