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.BufferedReader;
import java.io.FileReader;
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer; 
import java.util.*;
import java.io.*;
public class codeforces 
{ 
   static class Student{
       int x,y;//z;
        Student(int x,int y){
            this.x=x;
            this.y=y;
            //this.z=z;
        }
    }
    static int prime[];
    static void sieveOfEratosthenes(int n) 
    { 
        // Create a boolean array "prime[0..n]" and initialize 
        // all entries it as true. A value in prime[i] will 
        // finally be false if i is Not a prime, else true. 
        int pos=0;
        prime= new int[n+1]; 
        for(int p = 2; p*p <=n; p++) 
        { 
            // If prime[p] is not changed, then it is a prime 
            if(prime[p] == 0)
            { 
                // Update all multiples of p
                prime[p]=p;
                for(int i = p*p; i <= n; i += p)
                    if(prime[i]==0)
                    prime[i] = p; 
            } 
        } 
    }
static    class Sortbyroll implements Comparator<Student> 
{ 
    // Used for sorting in ascending order of 
    // roll number 
    public int compare(Student c, Student b) 
    {
        return c.x-b.x;
    } 
} 
static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
 
    static class Edge{
        int a,b;
        Edge(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    static class Trie{
        HashMap<Character,Trie>map;
         int c;
        Trie(){
            map=new HashMap<>();
            //z=null;
            //o=null;
            c=0;
        }
    }
    //static long ans;
    static int parent[];
    static int rank[];
    static int b[];
    static int bo[];
    static int ho[][];
    static int seg[];
    //static int pos;
    static long mod=1000000000+7;
    //static int dp[][];
    static HashMap<Integer,Integer>map;
    static PriorityQueue<Student>q=new PriorityQueue<>();
    //static Stack<Integer>st;
   // static ArrayList<Character>ans;
    static ArrayList<ArrayList<Integer>>adj;
    //static ArrayList<ArrayList<Integer>>tr;
    static ArrayList<HashMap<Long,Student>>map1;
    static ArrayList<HashMap<Long,Long>>map2;
    //static long ans;
    static int pos;
    static Trie root;
    static long fac[];
    static int gw,gb;
    //static long mod=(long)(998244353);
    static long ans;
    static void solve()throws IOException{
        FastReader sc=new FastReader();
        int n,i,x,y;
        long max=Long.MIN_VALUE;
        adj=new ArrayList<>();
        map1=new ArrayList<>();
        map2=new ArrayList<>();
        n=sc.nextInt();
        for(i=0;i<n;i++){
            adj.add(new ArrayList<>());
            //map1.add(new HashMap<>());
            //map2.add(new HashMap<>());
        }
        int a[]=new int[n];
        for(i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        for(i=0;i<n-1;i++){
            x=sc.nextInt()-1;
            y=sc.nextInt()-1;
            adj.get(x).add(y);
            adj.get(y).add(x);
        }
        long dp[]=new long[n];
        long dp1[][]=new long[n][2];
        for(i=0;i<n;i++){
            dp1[i][0]=Long.MIN_VALUE;
            dp1[i][1]=dp1[i][0];
        }
        dfs(0,0,a,dp);
        dfs2(0,0,dp1,dp);
          for(i=0;i<n;i++){
            if(dp1[i][0]!=Long.MIN_VALUE&&dp1[i][1]!=Long.MIN_VALUE)
                max=Math.max(max,dp1[i][0]+dp1[i][1]);
        }
        if(max==Long.MIN_VALUE)
            System.out.println("Impossible");
        else
            System.out.println(max);
    }
    static void dfs2(int p,int c,long dp1[][],long dp[]){
        for(Integer x: adj.get(c)){
            if(x==p)
                continue;
            dfs2(c,x,dp1,dp);
            dp[c]=Math.max(dp[c],dp[x]);
            if(dp1[c][0]==Long.MIN_VALUE)
                dp1[c][0]=dp[x];
            else if(dp1[c][0]<=dp[x]){
                dp1[c][1]=dp1[c][0];
                dp1[c][0]=dp[x];
            }
            else
                dp1[c][1]=Math.max(dp1[c][1],dp[x]);
        }
    }
    static void dfs(int p,int c,int a[],long dp[]){
        dp[c]=a[c];
        for(Integer x: adj.get(c)){
            if(x==p)
                continue;
            dfs(c,x,a,dp);
            dp[c]+=dp[x];
        }
    }
    static void dfs(int x,int y,char f[][],int n,int m){
        f[x][y]='u';
        if(x+1<n){
            if(f[x+1][y]=='*')
                ++pos;
            if(f[x+1][y]=='.')
                dfs(x+1,y,f,n,m);
        }
        if(x-1>=0){
            if(f[x-1][y]=='*')
                ++pos;
            if(f[x-1][y]=='.')
                dfs(x-1,y,f,n,m);
        }
        if(y+1<m){
            if(f[x][y+1]=='*')
                ++pos;
            if(f[x][y+1]=='.')
                dfs(x,y+1,f,n,m);
        }
        if(y-1>=0){
            if(f[x][y-1]=='*')
                ++pos;
            if(f[x][y-1]=='.')
                dfs(x,y-1,f,n,m);
        }
    }
    static void fill(int x,int y,char f[][],int dp[][],int n,int m){
        dp[x][y]=pos;
        f[x][y]='*';
           if(x+1<n){
            if(f[x+1][y]=='u')
                fill(x+1,y,f,dp,n,m);
        }
        if(x-1>=0){
            if(f[x-1][y]=='u')
                fill(x-1,y,f,dp,n,m);
        }
        if(y+1<m){
            if(f[x][y+1]=='u')
                fill(x,y+1,f,dp,n,m);
        }
        if(y-1>=0){
            if(f[x][y-1]=='u')
                fill(x,y-1,f,dp,n,m);
        }
    }
    static boolean check(String s){
        int i=0,j=s.length()-1;
        while(i<j){
            if(s.charAt(i)!=s.charAt(j))
                return false;
            ++i;
            --j;
        }
        return true;
    }
    static void update(int s,int e,int l,int r,int in,int v){
        if(s>e||s>r||l>e)
            return;
        if(s>=l&&e<=r){
            seg[in]=v;
            return;
        }
        int mid=(s+e)/2;
        update(s,mid,l,r,2*in+1,v);
        update(mid+1,e,l,r,2*in+2,v);
        seg[in]=Math.max(seg[2*in+1],seg[2*in+2]);
    }
        static int query(int s,int e,int l,int r,int in){
        if(s>e||s>r||l>e)
            return 0;
        if(s>=l&&e<=r){
            return seg[in];
            
        }
        int mid=(s+e)/2;
        return Math.max(query(s,mid,l,r,2*in+1),
        query(mid+1,e,l,r,2*in+2));
        //seg[in]=Math.max(seg[2*in+1],seg[2*in+2]);
    }
    static double dist(long x,long y,long z,long w){
        return Math.sqrt((x-y)*(x-y)+(z-w)*(z-w));
    }
    static void add(int x,int y,Queue<Integer>q,Queue<Integer>v,int b[][]){
        q.add(x);
        v.add(y);
        b[x][y]=1;
    }
    static long nCr(long n, long r, 
                                    long p) 
    { 
        return (fac[(int)n]* modInverse(fac[(int)r], p) 
                % p * modInverse(fac[(int)(n-r)], p) 
                                    % p) % p; 
    } 
    //static int prime[];
    //static int dp[];
    public static void main(String[] args){
        //long sum=0;
        try {
                codeforces.solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
       static long modInverse(long n, long p) 
    { 
        return power(n, p-(long)2,p); 
    } 
 static long power(long x, long y, long p) 
{ 
    long res = 1;      // Initialize result 
  
    x = x % p;  // Update x if it is more than or  
                // equal to p 
  
    while (y > 0) 
    { 
        // If y is odd, multiply x with result 
        if (y %(long)2!=0) 
            res = (res*x) % p; 
  
        // y must be even now 
        y = y>>1; // y = y/2 
        x = (x*x) % p;   
    } 
    return res%p;
 }
    /*public static long power(long x,long a) {
		if(a==0) return 1;
		if(a%2==1)return (x*1L*power(x,a-1))%mod;
		return (power((int)((x*1L*x)%mod),a/2))%mod;
	}*/
   static int find(int x) 
    { 
        // Finds the representative of the set 
        // that x is an element of 
        while(parent[x]!=x) 
        { 
            // if x is not the parent of itself 
            // Then x is not the representative of 
            // his set,
            x=parent[x];
  
            // so we recursively call Find on its parent 
            // and move i's node directly under the 
            // representative of this set 
        } 
  
        return x; 
    }
    static void union(int x, int y) 
    { 
        // Find representatives of two sets 
        int xRoot = find(x), yRoot = find(y); 
  
        // Elements are in the same set, no need 
        // to unite anything. 
        if (xRoot == yRoot) 
            return; 
  
         // If x's rank is less than y's rank 
        if (rank[xRoot] < rank[yRoot]) 
  
            // Then move x under y  so that depth 
            // of tree remains less 
            parent[xRoot] = yRoot; 
  
        // Else if y's rank is less than x's rank 
        else if (rank[yRoot] < rank[xRoot]) 
  
            // Then move y under x so that depth of 
            // tree remains less 
            parent[yRoot] = xRoot; 
  
        else // if ranks are the same 
        { 
            // Then move y under x (doesn't matter 
            // which one goes where) 
            parent[yRoot] = xRoot; 
  
            // And increment the the result tree's 
            // rank by 1 
            rank[xRoot] = rank[xRoot] + 1; 
        } 
    } 
    static long gcd(long a, long b) 
    { 
        if (a == 0){ 
             //ans+=b;
            return b;
        }
        return gcd(b % a, a); 
    }
}