Generous sponsors of the olympiad in which Chloe and Vladik took part allowed all the participants to choose a prize for them on their own. Christmas is coming, so sponsors decided to decorate the Christmas tree with their prizes. 

They took n prizes for the contestants and wrote on each of them a unique id (integer from 1 to n). A gift i is characterized by integer ai — pleasantness of the gift. The pleasantness of the gift can be positive, negative or zero. Sponsors placed the gift 1 on the top of the tree. All the other gifts hung on a rope tied to some other gift so that each gift hung on the first gift, possibly with a sequence of ropes and another gifts. Formally, the gifts formed a rooted tree with n vertices.

The prize-giving procedure goes in the following way: the participants come to the tree one after another, choose any of the remaining gifts and cut the rope this prize hang on. Note that all the ropes which were used to hang other prizes on the chosen one are not cut. So the contestant gets the chosen gift as well as the all the gifts that hang on it, possibly with a sequence of ropes and another gifts.

Our friends, Chloe and Vladik, shared the first place on the olympiad and they will choose prizes at the same time! To keep themselves from fighting, they decided to choose two different gifts so that the sets of the gifts that hang on them with a sequence of ropes and another gifts don't intersect. In other words, there shouldn't be any gift that hang both on the gift chosen by Chloe and on the gift chosen by Vladik. From all of the possible variants they will choose such pair of prizes that the sum of pleasantness of all the gifts that they will take after cutting the ropes is as large as possible.

Print the maximum sum of pleasantness that Vladik and Chloe can get. If it is impossible for them to choose the gifts without fighting, print Impossible.

Input

The first line contains a single integer n (1 ≤ n ≤ 2·105) — the number of gifts.

The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the pleasantness of the gifts.

The next (n - 1) lines contain two numbers each. The i-th of these lines contains integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the description of the tree's edges. It means that gifts with numbers ui and vi are connected to each other with a rope. The gifts' ids in the description of the ropes can be given in arbirtary order: vi hangs on ui or ui hangs on vi. 

It is guaranteed that all the gifts hang on the first gift, possibly with a sequence of ropes and another gifts.

Output

If it is possible for Chloe and Vladik to choose prizes without fighting, print single integer — the maximum possible sum of pleasantness they can get together.

Otherwise print Impossible.

Examples

Input

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


Output

25

Input

4
1 -5 1 1
1 2
1 4
2 3


Output

2

Input

1
-1


Output

Impossible
import java.io.*;
import java.math.BigInteger;
import java.util.*;
 
 
 
 public class Main {
	public static InputReader in;
    public static PrintWriter pw;
 
 
 
	public static void main(String args[]) {
		new Thread(null, new Runnable() {
            public void run() {
                try{
                    solve();
                }
                catch(Exception e){
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();
    }
	static ArrayList<Integer> g[];
	static ArrayList<Integer> h[];
	static boolean visited[];
	static boolean visit[];
	static int par[];
	static int degree[];
	static int edjes=0;
	static int start=-1;
	static int end=-1;
	static int Total=0;
	static int time1[];
	static int time2[];
	static int glob=0;
	static long cnt=0;
	static boolean vis2[][];
	static int lev=1;
    static int depth[];
    static long[] sm;
    static long val[];
    static int len=0;
    static long max1=Integer.MIN_VALUE;
    static int pre[][];
    static TreeSet<Long> max;
    public static void solve(){
		
	
		 in = new InputReader(System.in);
	 	 pw = new PrintWriter(System.out);
	 	 int n=in.nextInt();
	 	 g=new ArrayList[n+1];
	 	 for(int i=1;i<=n;i++)
	 		 g[i]=new ArrayList<Integer>();
	 	 val=new long[n+1];
	 	 max=new TreeSet();
	 	 for(int i=1;i<=n;i++)
	 		 val[i]=in.nextLong();
	 	 for(int i=1;i<n;i++)
	 	 {
	 		 int x=in.nextInt();
	 		 int y=in.nextInt();
	 		 g[x].add(y);
	 		 g[y].add(x);
	 	 }
	 	 visited=new boolean[n+1];
	 	 sm=new long[n+1];
	 	 dfs(1);
	 	 Arrays.fill(visited, false);
	 	 dfs1(1);
         if(max1==Integer.MIN_VALUE)
        	 System.out.println("Impossible");
         else
        	 System.out.println(max1);
    }
    public static void dfs(int curr)
    {
    	visited[curr]=true;
    	sm[curr]=val[curr];
    	for(int x:g[curr])
    	{
    		if(!visited[x])
    		{
    			dfs(x);
    			sm[curr]+=sm[x];
    		}
    	}
    }
    public static void dfs1(int curr)
    {
    	visited[curr]=true;
    	if(!max.isEmpty())
    	{
    		max1=Math.max(max1,sm[curr]+max.last());
    	}
    	for(int x:g[curr])
    	{
    		if(!visited[x])
    		{
    			dfs1(x);
    		}
    	}
    	max.add(sm[curr]);
    }
    
    
    
   public static int len(String s)
    {
    	
    	if(s.charAt(len++)=='l')
    	{
    		return 1;
    	}
    	else{
    		return Math.max(len(s), len(s))+1;
    	}
    }
    
    
   public static int LCA(int p,int q)
    {
    	if(depth[p]<depth[q])
		{
			int tmp=p;
			p=q;
			q=tmp;
		}
		int dist=depth[p]-depth[q];
		while(dist>0)
		{
			int raise=(int)(Math.log(dist)/Math.log(2));
			p=pre[p][raise];
			dist-=(1<<raise);
		}
		if(p==q)
		{
			return p;
		}
		else{
		
		int current=(int)(Math.log(depth[p])/Math.log(2));
		for(int j=current;j>=0;j--)
		{
			if(pre[p][j]!=0&&pre[p][j]!=pre[q][j])
			{
				p=pre[p][j];
				q=pre[q][j];
			}
		}
		}
	return par[p];
    }
    
public static void dfs(int curr,int lev,int parent)
{
     visited[curr]=true;
     depth[curr]=lev;
     par[curr]=parent;
    // set[lev].add(curr);
     for(int x:g[curr])
     {
    	 if(!visited[x])
    	 {
    		 dfs(x,lev+1,curr);
    	 }
     }
     
}


	



	public static int countNumber(int n)
    {
        int result = 0;
     
        // Pushing 1 to 9 because all number from 1
        // to 9 have this propert.
        for (int i = 1; i <= 9; i++)
        {
            Stack<Integer> s=new Stack();
            if (i <= n)
            {
                s.push(i);
                result++;
            }
     
            // take a number from stack and add
            // a digit smaller than last digit
            // of it.
            while (!s.empty())
            {
                int tp = s.peek();
                s.pop();
                for (int j = tp%10; j <= 9; j++)
                {
                    int x = tp*10 + j;
                 //   System.out.println(x);
                    if (x <= n)
                    {
                        s.push(x);
                        result++;
                    }
                }
              //  System.out.println();
            }
        }
     
        return result;
    }
    public static boolean IsPrime(long l) {
		// Corner cases
		if (l <= 1)
			return false;
		if (l <= 3)
			return true;
 
		// This is checked so that we can skip 
		// middle five numbers in below loop
		if (l % 2 == 0 || l % 3 == 0)
			return false;
 
		for (long i = 5; i * i <= l; i = i + 6)
			if (l % i == 0 || l % (i + 2) == 0)
				return false;
 
		return true;
	}
 
     
        
     
        

   
/*public static void dfs2(int curr,int lev)
{
	time1[curr]=glob++;
	
	depth[curr]=lev;
	visited[curr]=true;
	nodes[lev].add(time1[curr]);
	values[lev].add(a[curr]);
	for(int x:g[curr])
	{
		if(!visited[x])
		{
			dfs2(x,lev+1);
		}
	}
time2[curr]=glob++;
}
 
 
 
public static void bfs1(int curr)
{
Queue<Integer> Q=new LinkedList<Integer>();
Q.add(1);
visit[1]=true;
int lev=2;
levels[1].add(1);
while(!Q.isEmpty())
{
	int cnt=Q.size();
	while(cnt>0)
	{
		int p=Q.poll();
		visit[p]=true;
		for(int x:g[p])
		{
			if(!visit[x])
			{
				Q.add(x);
				levels[lev].add(x);
			}
		}
		cnt--;
	}
	max=Math.max(lev, max);
	lev++;
}
}
 
 
	
 	private static long fact(int len) {
	long ans=1;
	for(int i=1;i<=len;i++)
		ans*=i;
	return ans;
}
 */
 
 
	
	// SubTree Checker DFS (TO CHECK IF X IS IN A SUBTREE OF Y)
	public static void dfs3(int curr)
	{
		visited[curr]=true;
		time1[curr]=glob++;
		for(int x:g[curr])
		{
		if(!visited[x])
			dfs3(x);
		}
		time2[curr]=glob++;
	}
    
	
	
 
    /*NO OF EDJES IN WHOLE CONNECTED COMPONENTS
  
	public static void dfs1(int curr)
	{
		visited[curr]=true;
		for(int next:g[curr])
		{
			edje++;
			if(!visited[next])
				dfs1(next);
		}
	}
	/*SUM OF ALL SUBTREE NODE'S VLAUES DFS
	public static void dfs(int curr,int prev)
		{
		val[curr]=1;
			for(int x:g[curr])
			{
				if(x!=prev)
				{
		            dfs(x,curr);
		            val[curr]+=val[x];
					
			    }
			}
		}*/
	
		public static long power(long a,long b)
		{
			long result=1;
			while(b>0)
			{
				if(b%2==1)
					result*=a;
				a=a*a;
				b/=2;
			}
			return result;
		}
				public static long pow(long n,long p,long m)
	{
		 long  result = 1;
		  if(p==0)
		    return 1;
		if (p==1)
		    return n;
		while(p!=0)
		{
		    if(p%2==1)
		        result *= n;
		    if(result>=m)
		    result%=m;
		    p >>=1;
		    n*=n;
		    if(n>=m)
		    n%=m;
		}
		return result;
	}
	static class Pair implements Comparable<Pair>{
	int now;
		int aft;
		int index;
		Pair(int ver,int weight,int index){
	     	this.now=ver;
			this.aft=weight;
			this.index=index;
			
		}
		@Override
		public int compareTo(Pair o) {
			if((o.now-o.aft)-(now-aft)!=0)
				return (int)-((o.now-o.aft)-(now-aft));

				return (int)(o.now-now);
		}
				
	}
	public static long gcd(long a, long b) {
		  if (b == 0) return a;
		  return gcd(b, a%b);
		}
	static class InputReader {
 
		private InputStream stream;
		private byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;
 
		public InputReader(InputStream stream) {
			this.stream = stream;
		}
 
		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
 
		public   int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}
 
		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
 
		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}