Problem: Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them.

Each command is one of the following two types: 

  1. Go 1 unit towards the positive direction, denoted as '+'
  2. Go 1 unit towards the negative direction, denoted as '-'



But the Wi-Fi condition is so poor that Dreamoon's smartphone reports some of the commands can't be recognized and Dreamoon knows that some of them might even be wrong though successfully recognized. Dreamoon decides to follow every recognized command and toss a fair coin to decide those unrecognized ones (that means, he moves to the 1 unit to the negative or positive direction with the same probability 0.5). 

You are given an original list of commands sent by Drazil and list received by Dreamoon. What is the probability that Dreamoon ends in the position originally supposed to be final by Drazil's commands?

Input

The first line contains a string s1 — the commands Drazil sends to Dreamoon, this string consists of only the characters in the set {'+', '-'}. 

The second line contains a string s2 — the commands Dreamoon's smartphone recognizes, this string consists of only the characters in the set {'+', '-', '?'}. '?' denotes an unrecognized command.

Lengths of two strings are equal and do not exceed 10.

Output

Output a single real number corresponding to the probability. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 9.

Examples

Input

++-+-
+-+-+


Output

1.000000000000


Input

+-+-
+-??


Output

0.500000000000


Input

+++
??-


Output

0.000000000000

Note

For the first sample, both s1 and s2 will lead Dreamoon to finish at the same position  + 1. 

For the second sample, s1 will lead Dreamoon to finish at position 0, while there are four possibilites for s2: {"+-++", "+-+-", "+--+", "+---"} with ending position {+2, 0, 0, -2} respectively. So there are 2 correct cases out of 4, so the probability of finishing at the correct position is 0.5. 

For the third sample, s2 could only lead us to finish at positions {+1, -1, -3}, so the probability to finish at the correct position  + 3 is 0.

Solution (in JAVA):

Solution:

    		import java.awt.List;
    		import java.io.*;
    		import java.util.*;

    		
    		
    		/*
    		 * 
    		 * daiict
    		 *
    		 * 
    		 * 
    		 */
    		
    		
    		public class prac {
    			FastScanner in;
    			PrintWriter out;
    		
    			static ArrayList[] adj;
    			
    			static int n;
    			static int m;
    			
    			static int[] dp1;
    			static int[] dp2;
    			static int color[];
    			static int visited[];
    			static long[] arr;
    			static long[] brr;
    			static long ans;
    			static int array[];
    			static int pref[];
    			static int tree[];
    			static int maxval = 32;
    		
    			static int sum = 0;
    		//for dfs do not delete
    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
    			
    		
    			static long[] seg;
    			static long count = 1;
    			static long mod = (long)1e9 + 7;
    	
    			static int parent[];
    			static int size[];
    			
    			static class Pair implements Comparable<Pair>
    		    {
    				long x;int y;
    				
    		        Pair(long l, int m) {
    		          
    		        	this.x = l;
    		            this.y = m;
    		          
    		        }
    		        
    		        public int compareTo(Pair p) {
    		            if (this.x == p.x) {
    		                return (int)(this.y-p.y);
    		            }
    		            return (int)(this.x - p.x);
    		        }
    		        
    		        public String toString(){
    		        	return x + " " + y;
    		        }
    		        
    		        public boolean equals(Object o){
    		        	if(o instanceof Pair){
    		        		Pair a = (Pair)o;
    		        		
    		        		return this.x == a.x;
    		        	}
    		        	
    		        	return false;
    		        }
    		        
    		        public int hashCode(){
    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
    		        }
    		    
    		    }
    		    
    			
    			public static int gcd(int a, int b) {
    				if (b == 0) return a;
    				return gcd(b, a%b);
    			}
    	
    			void build(int n) {  // build the tree
    				  for (int i = n - 1; i > 0; --i) seg[i] = Math.max(seg[i<<1],seg[i<<1|1]);
    				}
     
    			public static void modify(int p, int i,long val,int n) {  // set value at position p
    					if(i == 1){
    						long temp = val;
    						val = seg[p+n] - arr[p] + val;
    						arr[p] = temp;
    					}else{
    						val = Math.min(val, p) + arr[p];
    						brr[p] = val;
    					}
    					
    				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.max(seg[p],seg[p^1]);
    				}
     
    				long query(int l, int r,int n) {  // max on interval [l, r)
    				  long res = Integer.MIN_VALUE;
    				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
    				    if ((l&1) == 1) res = (int)Math.max(res,seg[l++]);
    				    if ((r&1) == 1) res = (int)Math.max(res,seg[--r]);
    				  }
    				  return res;
    				}
    				
    			public static void update(int x,int val){
    				while(x<=maxval){
    					tree[x] += val;
    					x = (x&-x);
    				}
    			}
    			
    			public static int read(int idx){
    				int sum = 0;
    				
    				while(idx>= 0){
    					sum += tree[idx];
    					idx -= (idx&(-idx));
    				}
    				
    				return sum;
    			}
    			
    			public static int find(int i){
    				if(parent[i] != i){
    					return find(parent[i]);
    				}
    				
    				return i;
    			}
    			
    			public static void union(int a,int b){
    				int x = find(a);
    				int y = find(b);
    				
    				if(x!=y){
    					if(size[x] > size[y]){
    						size[x] += size[y];
    						parent[y] = x;
    					}else{
    						size[y] += size[x];
    						parent[x] = y;
    					}
    				}
    			}
    			
    		    void solve() throws NumberFormatException, IOException {
    		 
    		    	//Scanner in = new Scanner(System.in);
    		    	
    		    	String s = in.next();
    		    	String t = in.next();
    		    	
    		    	int a = 0;
    		    	int b = 0;
    		    	
    		    	for(int i = 0;i<s.length();i++){
    		    		if(s.charAt(i) == '+'){
    		    			a++;
    		    		}
    		    		if(t.charAt(i) == '+'){
    		    			a--;
    		    		}else if(t.charAt(i) == '?'){
    		    			b++;
    		    		}
    		    		
    		    		
    		    	}
    		    	double ans;
    		    	if(a > b || a < 0){
    		    		ans = 0;
    		    	}else{
    		    		ans = (double)fact(b,a)/(Math.pow(2, b));
    		    	}
    		    	
    		    	out.println(ans);
    		    	
    		    	
    		    	
	    
    		    }
    		    
    		    public static int fact(int a,int b){
    		    	if(b == 0){
    		    		return 1;
    		    	}
    		    	
    		    	return a*fact(a-1,b-1)/b;
    		    }
    		    
    		    public static void ddfss(int i,int p){
    		    	
    		    	array[i] = color[p];
    		    	
    		    	for(int j = 0;j<adj[i].size();j++){
    		    		if((int)adj[i].get(j) != p){
    		    			
    		    			ddfss((int)adj[i].get(j),i);
    		    		}
    		    	}
    		    }
    		    
    		    public static void ddfs(int i,int p){

    		    	//System.out.println(i + " " +p);
    		    	
    		    	if(color[i] != array[i]){
    		    		sum++;
    		    	//	System.out.println(i + "dd");
    		    		ddfss(i,p);
    		    		
    		    	}
	
    		    	for(int j = 0;j<adj[i].size();j++){
    		    		if((int)adj[i].get(j) != p){
    		    			ddfs((int)adj[i].get(j),i);
    		    		}
    		    	}
    		    	
    		    }
    		    
    		    public static long invcount(int arr[]){
    		    	if(arr.length<2){
    		    		return 0;
    		    	}
    		    	
    		    	int mid = (arr.length + 1)/2;
    		    	
    		    	int left[] = Arrays.copyOfRange(arr, 0,mid);
    		    	int right[] = Arrays.copyOfRange(arr, mid, arr.length);
    		    	
    		    	return invcount(left)+invcount(right)+merge(arr,left,right);
    		    	
    		    }
    		    
    		    public static long merge(int arr[],int left[],int right[]){
    		    	long count = 0;
    		    	
    		    	int i = 0;
    		    	int j = 0;
    		    	
    		    	while(i<left.length || j < right.length){
    		    		
    		    		if(i == left.length){
    		    			arr[i+j] = right[j];
    		    			j++;
    		    		}else if(j == right.length){
    		    			arr[j+i] = left[i];
    		    			i++;
    		    		}else{
    		    			if(left[i] <= right[j]){
    		    				arr[i+j] = left[i];
    		    				i++;
    		    			}else{
    		    				arr[i+j] = right[j];
    		    				j++;
    		    				count += left.length-i;
    		    			}
    		    		}
    		    		
    		    	}
    		    	
    		    	return count;
    		    }
    		    
    		  
    		    
    		    /**
    		     * 
    		     * @param div
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return the smallest index i which a[i] >= value in range [left, right) if exists, otherwise return -1
    		     */
    		    int ff(int[] div, int left, int right, int value) {
    		        int low = left;
    		        int high = right;
    		        
    		        if(value > div[right-1]){
    		        	return left;
    		        }
    		        
    		        while (low != high) {
    		            int mid = (low + high) / 2;
    		            if (div[mid] < value) {
    		                low = mid + 1;
    		            } else {
    		                high = mid;
    		            }
    		        }
    		        if (low == right) {
    		            return low;
    		        }
    		        return low;
    		    } 
    		   
    		    /**
    		     * 
    		     * @param div
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return greatest index i which a[i] <= value in range [left, right) if exists, otherwise return a number out of [left, right)
    		     */
    		    int ffff(int[] div, int left, int right, int value) {
    		        
    		    	if(value < div[left]){
    		    		return right-1;
    		    	}
    		    	
    		    	while (left != right) {
    		            int mid = (left + right) >> 1;
    		            if (div[mid] <= value) {
    		                left = mid + 1;
    		            } else {
    		                right = mid;
    		            }
    		        }
    		        if (left < 0) {
    		            left *= -1;
    		        }
    		        return --left;
    		    }
	    
    		   
    		  
    		
    		    public static String reverse(String s){
    		    	
    		    	String ans = "";
    		    	
    		    	for(int i = s.length()-1;i>=0;i--){
    		    		ans += s.charAt(i);
    		    	}
    		    	
    		    	return ans;
    		    	
    		    }
    			
    			
    		    
    		 
    		    public static long sum(long x){
    		    	return x<10?x:x%10 + sum(x/10);
    		    }
    			
    			public static long gcd(long x, long y) {
    				if (x == 0)
    					return y;
    				else
    					return gcd( y % x,x);
    			}
    			static long inv(long x , long mod)
    			{
    				long r,y;
    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
    				{
    					if((y&1)==1)
    						r=r*x%mod;
    				
    				}
    				return r;
    			}
    			
    			public static long pow(long x,long y,long n){
    				if(y==0)
    					return 1%n;
    				if(y%2==0){
    					long z=pow(x,y/2,n);
    					return (z*z)%n;
    				}
    				return ((x%n)*pow(x,y-1,n))%n;
    			}
    			
    			
    			
    			
    			public static boolean isPrime(int n) {
    				// Corner cases
    				if (n <= 1)
    					return false;
    				if (n <= 3)
    					return true;
    		 
    				// This is checked so that we can skip 
    				// middle five numbers in below loop
    				if (n % 2 == 0 || n % 3 == 0)
    					return false;
    		 
    				for (int i = 5; i * i <= n; i = i + 6)
    					if (n % i == 0 || n % (i + 2) == 0)
    						return false;
    		 
    				return true;
    			}
    			
    		
    			void run() throws NumberFormatException, IOException {
    				in = new FastScanner();
    				out = new PrintWriter(System.out);
    		
    				solve();
    		
    				out.close();
    			}
    		
    			class FastScanner {
    				BufferedReader br;
    				StringTokenizer st;
    		
    				public FastScanner() {
    					br = new BufferedReader(new InputStreamReader(System.in));
    				}
    		
    				String next() {
    					while (st == null || !st.hasMoreTokens()) {
    						try {
    							st = new StringTokenizer(in.br.readLine());
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    					return st.nextToken();
    				}
    		
    				int nextInt() {
    					return Integer.parseInt(next());
    				}
    		
    				long nextLong() {
    					return Long.parseLong(next());
    				}
    		
    				double nextDouble() {
    					return Double.parseDouble(next());
    				}
    			}
    			
    			
    			
    			
    		 
    		
    			public static void main(String[] args) throws NumberFormatException, IOException {
    				new prac().run();
    			}
    		}
    		class Node{
    			String s;
    			int b;
    			
    		}
    		
    		class MyComp implements Comparator<String>{
    		    
    			int c = 0;
    			
    			MyComp(int d){
    				c = d;
    			}
    			
    			@Override
    			public int compare(String a,String b) {
    				
    				// < == -1
    				
    				String arr[] = a.split(" ");
    				String brr[] = b.split(" ");
    				
    				return arr[c].compareTo(brr[c]);
    				
    				
    			}

    			
    		}
    		
    		class MyComp2 implements Comparator<Node>{
    		    
    		
    			
    			@Override
    			public int compare(Node a,Node b) {
    				
    				// < == -1

    				
    				if(a.b > b.b){
    					return -1;
    				}else{
    					return 1;
    				}
    				
    				
    			}

    			
    		}