#include<iostream>
#include<cstdlib>
#include<vector>
#include<algorithm>
#include<cmath>
#include<map>
#include<list>

using namespace std;

struct subst
{
    int ilosc;
    //int lokacja;
    map<int,int> priorytet_reakcji;
    //list<int> skladnikiWFiolce;
    //map< list<int> > mozliweReakcje;
};

struct fiolka
{
   // int ilosc;
    //int lokacja;
   // map<int> priorytet_reakcji;
    list<int> skladnikiWFiolce;
    map< int,list<int> > mozliweReakcje;
};

struct krok
{
    int from;
    int to;
};

struct reakcja
{
    int a, b;
    int priorytet;
    reakcja():
    a(0),priorytet(0)
    {
    }
    reakcja(int aa, int bb,int pp):
    a(aa),b(bb),priorytet(pp)
    {
    }
};

bool porown(const reakcja& a, const reakcja& b)
{
     return a.priorytet < b.priorytet;
}

int main()
{

    int m,n,k;

    //cin>>m>>n>>k;
    scanf("%d%d%d",&n,&m,&k);
    vector<subst> substance(n);
    vector<krok> sekwencja(m);
    vector<fiolka> fiolki(n);

    for(int i = 0; i < n; i++)
    {
        scanf("%d",&substance[i].ilosc);
        fiolki[i].skladnikiWFiolce.push_back(i);
        //substance[i].lokacja = i;
    }

    for(int i = 0; i < m; i++)
    {
        scanf("%d%d",&sekwencja[i].from, &sekwencja[i].to);
		--sekwencja[i].from;
		--sekwencja[i].to;
    }

    for(int i = 0; i < k; i++)
    {
        int c, d;
        scanf("%d%d",&c, &d);
        --c;
        --d;
        substance[c].priorytet_reakcji[d] = i;
        substance[d].priorytet_reakcji[c] = i;
        fiolki[d].mozliweReakcje[c].push_back(d);//[c-1] = i;
        fiolki[c].mozliweReakcje[d].push_back(c);
    }

    long long int osad = 0;

    for(int i = 0; i < m; i++)
    {
        int from = sekwencja[i].from;
        int to = sekwencja[i].to;

        vector<reakcja> reakcje;

        {
            int from2, to2;

            if(fiolki[from].skladnikiWFiolce.size() < fiolki[to].skladnikiWFiolce.size())
            {
                from2 = from;
                to2 = to;
            }
            else
            {
                from2 = to;
                to2 = from;
            }

            list<int>::iterator it = fiolki[from2].skladnikiWFiolce.begin();
            list<int>::iterator itEnd = fiolki[from2].skladnikiWFiolce.end();
            for( ;it != itEnd;)
            {
                if(substance[*it].ilosc > 0)
                {
                    map< int, list<int> >::iterator listaReakcji = fiolki[to2].mozliweReakcje.find(*it);
                    if(  listaReakcji != fiolki[to2].mozliweReakcje.end() )
                    {
                        list<int>::iterator it2 = listaReakcji->second.begin();
                        for(;it2 != listaReakcji->second.end();it2++)
                        {
                            if(substance[*it2].ilosc > 0)
                            {
                                reakcje.push_back(reakcja(*it, *it2, substance[*it].priorytet_reakcji[*it2]));
                            }
                            else
                            {
                                 fiolki[to2].mozliweReakcje.erase(*it2);
                            }
                        }
                        fiolki[to2].mozliweReakcje.erase(listaReakcji); // nic z tej fiolki już nie zareaguje z substancją *it;
                    }
                    it++;
                }
                else
                {
                    it = fiolki[from2].skladnikiWFiolce.erase(it);
                }
            }
        }
        if(reakcje.size() != 0)
        {
            sort(reakcje.begin(),reakcje.end(), porown);
            //cout << "sort:"<<endl;
            //fiolki[to].skladnikiWFiolce.clear();
            for(int i = 0; i <reakcje.size(); i++)
            {
                int ila = substance[reakcje[i].a].ilosc;
                int ilb = substance[reakcje[i].b].ilosc;
                if(ila > 0 && ilb > 0)
                {
                    //cout << reakcje[i].a <<" "<<ila<<" "<<reakcje[i].b<<" "<<ilb<<" "<<reakcje[i].priorytet<<endl;
                    if(ila > ilb) // skladnik b jest skasowany
                    {
                        osad += 2*ilb;
                        substance[reakcje[i].a].ilosc -= ilb;
                        substance[reakcje[i].b].ilosc -= ilb;
                        //fiolki[to].skladnikiWFiolce.push_back(reakcje[i].a);
                        //do_dodania.push_back(reakcje[i].a);
                        //fiolki[to].mozliweReakcje
                        //fiolki[to].skladnikiWFiolce.erase();
                    }
                    else
                    {
                        osad += 2*ila;
                        substance[reakcje[i].a].ilosc -= ila;
                        substance[reakcje[i].b].ilosc -= ila;
                    }
                 //cout <<"a:"<< reakcje[i].a <<" "<<ila<<", b:"<<reakcje[i].b<<" "<<ilb<<" "<<reakcje[i].priorytet<<", sum: "<<osad<<endl;
                }
            }
        }

		if(fiolki[to].mozliweReakcje.size() < fiolki[from].mozliweReakcje.size())
		{
			fiolki[to].mozliweReakcje.swap( fiolki[from].mozliweReakcje );
		}

		map< int, list<int> >::iterator listaReakcjiFrom =  fiolki[from].mozliweReakcje.begin();

		for(;listaReakcjiFrom != fiolki[from].mozliweReakcje.end();listaReakcjiFrom++)
		{
			if( substance[listaReakcjiFrom->first].ilosc > 0 )
			{
			    list<int>& copy = fiolki[to].mozliweReakcje[listaReakcjiFrom->first];
				copy.splice(copy.begin(), listaReakcjiFrom->second);
			}
			/*else nie wydajne!
			{
			    map< int, list<int> >::iterator toErase =  fiolki[to].mozliweReakcje.find(listaReakcjiFrom->first);
			    if(toErase !=  fiolki[to].mozliweReakcje.end())
			    {
			         fiolki[to].mozliweReakcje.erase(toErase);
			    }
			}*/
		}
        fiolki[from].mozliweReakcje.clear();

		if(fiolki[to].skladnikiWFiolce.size() < fiolki[from].skladnikiWFiolce.size())
		{
			fiolki[to].skladnikiWFiolce.swap( fiolki[from].skladnikiWFiolce );
		}

        list<int>::iterator it2 = fiolki[from].skladnikiWFiolce.begin();
        list<int>::iterator itEnd2 = fiolki[from].skladnikiWFiolce.end();
        for( ;it2 != itEnd2; it2++)
        {
            if(substance[*it2].ilosc > 0)
            {
                fiolki[to].skladnikiWFiolce.push_back(*it2);
            }
        }


        //fiolki[to].mozliweReakcje.insert(fiolki[from].mozliweReakcje.begin(),fiolki[from].mozliweReakcje.end());
    }

    cout<< osad <<endl;

    return 0;
}