You are given a forest with N vertices and M edges. The vertices are numbered 0 through N-1. The edges are given in the format (x_i,y_i), which means that Vertex x_i and y_i are connected by an edge.

Each vertex i has a value a_i. You want to add edges in the given forest so that the forest becomes connected. To add an edge, you choose two different vertices i and j, then span an edge between i and j. This operation costs a_i + a_j dollars, and afterward neither Vertex i nor j can be selected again.

Find the minimum total cost required to make the forest connected, or print `Impossible` if it is impossible.

Constraints

* 1 ≤ N ≤ 100,000
* 0 ≤ M ≤ N-1
* 1 ≤ a_i ≤ 10^9
* 0 ≤ x_i,y_i ≤ N-1
* The given graph is a forest.
* All input values are integers.

Input

Input is given from Standard Input in the following format:


N M
a_0 a_1 .. a_{N-1}
x_1 y_1
x_2 y_2
:
x_M y_M


Output

Print the minimum total cost required to make the forest connected, or print `Impossible` if it is impossible.

Examples

Input

7 5
1 2 3 4 5 6 7
3 0
4 0
1 2
1 3
5 6


Output

7


Input

5 0
3 1 4 1 5


Output

Impossible


Input

1 0
5


Output

0
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.Arrays;
import java.util.Scanner;
import java.util.ArrayList;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        final int INF = (int) 1e9 + 1;

        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int N = in.nextInt();
            int M = in.nextInt();
            int[] a = new int[N];
            for (int i = 0; i < a.length; i++) {
                a[i] = in.nextInt();
            }
            List<Integer>[] G = new List[N];
            for (int i = 0; i < G.length; i++) {
                G[i] = new ArrayList<>();
            }
            UnionFind uf = new UnionFind(N);
            for (int i = 0; i < M; i++) {
                int x = in.nextInt();
                int y = in.nextInt();
                G[x].add(y);
                G[y].add(x);
                uf.unite(x, y);
            }
            if (uf.size() == 1) {
                out.println(0);
                return;
            }
            int need = (uf.size() - 1) << 1;
            if (need > N) {
                out.println("Impossible");
                return;
            }
            long ans = 0;
            int[] mi = new int[N];
            int[] idx = new int[N];
            Arrays.fill(mi, INF);
            for (int i = 0; i < N; i++) {
                if (mi[uf.find(i)] > a[i]) {
                    mi[uf.find(i)] = a[i];
                    idx[uf.find(i)] = i;
                }
            }
            for (int i = 0; i < N; i++) {
                if (mi[i] < INF) {
                    ans += mi[i];
                    a[idx[i]] = INF;
                    need--;
                }
            }
            Arrays.sort(a);
            for (int i = 0; i < need; i++) {
                ans += a[i];
            }
            out.println(ans);
        }

    }

    static class UnionFind {
        private int[] uni;
        private int size_;

        public UnionFind(int n) {
            this.uni = new int[n];
            Arrays.fill(this.uni, -1);
            this.size_ = n;
        }

        public int find(int v) {
            if (this.uni[v] < 0) {
                return v;
            } else {
                return this.uni[v] = this.find(this.uni[v]);
            }
        }

        public boolean unite(int a, int b) {
            a = this.find(a);
            b = this.find(b);
            if (a == b) {
                return false;
            }
            this.size_--;
            if (this.uni[a] > this.uni[b]) {
                int tmp = a;
                a = b;
                b = tmp;
            }
            this.uni[a] += this.uni[b];
            this.uni[b] = a;
            return true;
        }

        public int size() {
            return this.size_;
        }

    }
}

