Problem: Ringo has an undirected graph G with N vertices numbered 1,2,...,N and M edges numbered 1,2,...,M. Edge i connects Vertex a_{i} and b_{i} and has a length of w_i.

Now, he is in the middle of painting these N vertices in K colors numbered 1,2,...,K. Vertex i is already painted in Color c_i, except when c_i = 0, in which case Vertex i is not yet painted.

After he paints each vertex that is not yet painted in one of the K colors, he will give G to Snuke.

Based on G, Snuke will make another undirected graph G' with K vertices numbered 1,2,...,K and M edges. Initially, there is no edge in G'. The i-th edge will be added as follows:

* Let x and y be the colors of the two vertices connected by Edge i in G.
* Add an edge of length w_i connecting Vertex x and y in G'.



What is the minimum possible sum of the lengths of the edges in the minimum spanning tree of G'? If G' will not be connected regardless of how Ringo paints the vertices, print -1.

Constraints

* 1 \leq N,M \leq 10^{5}
* 1 \leq K \leq N
* 0 \leq c_i \leq K
* 1 \leq a_i,b_i \leq N
* 1 \leq w_i \leq 10^{9}
* The given graph may NOT be simple or connected.
* All input values are integers.

Input

Input is given from Standard Input in the following format:


N M K
c_1 c_2 ... c_{N}
a_1 b_1 w_1
:
a_M b_M w_M


Output

Print the answer.

Examples

Input

4 3 3
1 0 1 2
1 2 10
2 3 20
2 4 50


Output

60


Input

5 2 4
0 0 0 0 0
1 2 10
2 3 10


Output

-1


Input

9 12 9
1 2 3 4 5 6 7 8 9
6 9 9
8 9 6
6 7 85
9 5 545631016
2 1 321545
1 6 33562944
7 3 84946329
9 7 15926167
4 7 53386480
5 8 70476
4 6 4549
4 8 8


Output

118901402


Input

18 37 12
5 0 4 10 8 7 2 10 6 0 9 12 12 11 11 11 0 1
17 1 1
11 16 7575
11 15 9
10 10 289938980
5 10 17376
18 4 1866625
8 11 959154208
18 13 200
16 13 2
2 7 982223
12 12 9331
13 12 8861390
14 13 743
2 10 162440
2 4 981849
7 9 1
14 17 2800
2 7 7225452
3 7 85
5 17 4
2 13 1
10 3 45
1 15 973
14 7 56553306
16 17 70476
7 18 9
9 13 27911
18 14 7788322
11 11 8925
9 13 654295
2 10 9
10 1 545631016
3 4 5
17 12 1929
2 11 57
1 5 4
1 17 7807368


Output

171

Solution (in CPP):

Solution:
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;

#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define EACH(i, s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T1, class T2> ostream& operator << (ostream &s, pair<T1,T2> P)
{ return s << '<' << P.first << ", " << P.second << '>'; }
template<class T> ostream& operator << (ostream &s, vector<T> P)
{ for (int i = 0; i < P.size(); ++i) { if (i > 0) { s << " "; } s << P[i]; } return s; }
template<class T> ostream& operator << (ostream &s, vector<vector<T> > P)
{ for (int i = 0; i < P.size(); ++i) { s << endl << P[i]; } return s << endl; }
template<class T1, class T2> ostream& operator << (ostream &s, map<T1,T2> P)
{ EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; } return s << endl; }


const int MAX = 210000;
const int MAX_UF = MAX;
struct UnionFind {
    int size_;
    int par[MAX_UF];
    int rank[MAX_UF];
    int weight[MAX_UF];
    
    UnionFind(int n = 0) {size_ = n; for (int i = 0; i < n; ++i) par[i] = i, rank[i] = 0;}
    void init(int n) {size_ = n; for (int i = 0; i < n; ++i) par[i] = i, rank[i] = 0, weight[i] = -1;}
    int root(int x) {return par[x] == x ? x : par[x] = root(par[x]);}
    bool same(int x, int y) {return root(x) == root(y);}
    int get(int x) { return weight[root(x)]; }
    void set(int x, int w) { weight[root(x)] = w; }
    friend ostream& operator << (ostream& s, UnionFind uf) {
        vector<vector<int> > res = uf.group();
        for (int i = 0; i < res.size(); ++i) { s << uf.get(res[i][0]) << ", " << res[i]; }
        return s;
    }
    
    void connect(int x, int y) {
        x = root(x); y = root(y);
        if (x == y) return;
        if (rank[x] < rank[y]) par[x] = y;
        else {par[y] = x; if (rank[x] == rank[y]) ++rank[x];}
    }
    
    vector<vector<int> > group() {
        vector<vector<int> > res;
        vector<bool> fixed(size_, false);
        for (int i = 0; i < size_; ++i) {
            if (!fixed[i]) {
                vector<int> temp;
                for (int j = i; j < size_; ++j) {
                    if (same(i, j)) temp.push_back(j), fixed[j] = true;
                }
                res.push_back(temp);
            }
        }
        return res;
    }
} uf;

int N, M, K;
typedef pair<int,int> pint;
typedef pair<long long, pint> Edge;
vector<Edge> G;
int C[MAX];

map<int,int> ma;

int main() {
    while (cin >> N >> M >> K) {
        for (int i = 0; i < N; ++i) cin >> C[i];
        G.clear();
        ma.clear();
        
        int iter = K;
        for (int i = 0; i < M; ++i) {
            int a, b, w;
            cin >> a >> b >> w;
            --a, --b;
            int ua, ub;
            
            if (C[a] != 0) ua = C[a] - 1;
            else if (ma.count(a)) ua = ma[a];
            else {
                ua = iter;
                ma[a] = iter++;
            }
            
            if (C[b] != 0) ub = C[b] - 1;
            else if (ma.count(b)) ub = ma[b];
            else {
                ub = iter;
                ma[b] = iter++;
            }
            
            G.push_back(Edge(w, pint(ua, ub)));
        }
        
        sort(G.begin(), G.end());
        uf.init(N+K);
        
        //COUT(G);
        
        int con = 0;
        long long res = 0;
        for (auto e : G) {
            int u = e.second.first;
            int v = e.second.second;
            long long w = e.first;
            
            if (uf.same(u, v)) continue;
            uf.connect(u, v);
            ++con;
            res += w;
            
            if (con == K - 1) break;
        }
        
        if (con >= K - 1) cout << res << endl;
        else cout << -1 << endl;
    }
}