/*

 找割边是否存在

 */

 #include <cstdio>

 #include <cstring>

 #include <iostream>

 #include <stack>

 using namespace std;

 typedef long long ll;

 const int N = ;

 const int INF = ;

 int first[N] , k , k_scc , val[N] , val_scc[N] , sum[N] , all ;

 int scc[N] , num_of_scc , dfs_clock , dfn[N] , low[N];

 stack<int> s;

 struct Edge{

     int x , y , next ;

     bool flag;

 }e[N<<] , e_scc[N<<];

 int my_abs(int x)

 {

     return x>=?x:-x;

 }

 void add_edge(int x , int y)

 {

     e[k].x = x , e[k].y = y , e[k].next = first[x];

     first[x] = k++;

 }

 void add_edge_scc(int x , int y)

 {

     e_scc[k_scc].x = x , e_scc[k_scc].y = y , e_scc[k_scc].next = first[x] , e_scc[k_scc].flag = false;

     first[x] = k_scc++;

 }

 void tarjan(int u , int fa)

 {

     dfn[u] = low[u] = ++dfs_clock;

     s.push(u);

     int flag = ; //用来解决重边情况

     for(int i=first[u] ; i!=- ; i=e[i].next){

         int v = e[i].y;

         /*

         因为第一次遇到父节点的边，表示是一开始下来的边，这个是不允许访问的，

         但是如果遇到2次及以上，说明u v之间不止一条边，访问到第二次之后的边是允许

         low[u]通过这个重边得到dfn[v]比较下的较小值进行更新

         */

         if(v == fa && flag){

             flag = ;

             continue;

         }

         if(!dfn[v]){

             tarjan(v,u);

             low[u] = min(low[u] , low[v]);

         }

         else if(!scc[v])

             low[u] = min(low[u] , dfn[v]);

     }

     if(low[u] == dfn[u]){

         num_of_scc++;

         while(true){

             int x = s.top();

             s.pop();

             scc[x] = num_of_scc;

             val_scc[num_of_scc] += val[x];//得到新构建图上的点的权值

             if(x == u) break;

         }

     }

 }

 void dfs(int u , int fa)

 {

     sum[u] = val_scc[u];

     for(int i=first[u] ; i!=- ; i=e_scc[i].next){

         int v = e_scc[i].y;

         if(v == fa) continue;

         e_scc[i].flag = true;

         dfs(v , u);

         sum[u]+=sum[v];

     }

 }

 int main()

 {

   //  freopen("a.in" , "r" , stdin);

     int n , m , x , y;

     while(scanf("%d%d" , &n , &m) == ){

         memset(first , - , sizeof(first));

         k= , all = ;

         for(int i= ; i<n ; i++)

         {

             scanf("%d" , val+i);

             all += val[i];

         }

         for(int i= ; i<m ; i++){

             scanf("%d%d" , &x , &y);

             add_edge(x , y);

             add_edge(y , x);

         }

         //强连通分量缩点

         dfs_clock =  , num_of_scc = ;

         memset(dfn ,  ,sizeof(dfn));

         memset(scc ,  , sizeof(scc));

         memset(val_scc ,  , sizeof(val_scc));

         tarjan( , -);

         if(num_of_scc == ){

             puts("impossible");

             continue;

         }

         //重新构建一个以连通分量缩点后的树形图

         memset(first , - , sizeof(first));

         k_scc = ;

         for(int i= ; i<k ; i++){

             if(scc[e[i].x] == scc[e[i].y]) continue;

             add_edge_scc(scc[e[i].x] , scc[e[i].y]);

         }

         dfs( , -);

         int minn = INF;

         for(int i= ; i<k_scc ; i++){

             if(!e_scc[i].flag) continue;

             minn = min(minn , my_abs(all - sum[e_scc[i].y] - sum[e_scc[i].y]) );

         }

         printf("%d\n" , minn);

     }

     return ;

 }