Vasily exited from a store and now he wants to recheck the total price of all purchases in his bill. The bill is a string in which the names of the purchases and their prices are printed in a row without any spaces. Check has the format "name1price1name2price2...namenpricen", where namei (name of the i-th purchase) is a non-empty string of length not more than 10, consisting of lowercase English letters, and pricei (the price of the i-th purchase) is a non-empty string, consisting of digits and dots (decimal points). It is possible that purchases with equal names have different prices.

The price of each purchase is written in the following format. If the price is an integer number of dollars then cents are not written.

Otherwise, after the number of dollars a dot (decimal point) is written followed by cents in a two-digit format (if number of cents is between 1 and 9 inclusively, there is a leading zero).

Also, every three digits (from less significant to the most) in dollars are separated by dot (decimal point). No extra leading zeroes are allowed. The price always starts with a digit and ends with a digit.

For example:

  * "234", "1.544", "149.431.10", "0.99" and "123.05" are valid prices, 
  * ".333", "3.33.11", "12.00", ".33", "0.1234" and "1.2" are not valid. 



Write a program that will find the total price of all purchases in the given bill.

Input

The only line of the input contains a non-empty string s with length not greater than 1000 — the content of the bill.

It is guaranteed that the bill meets the format described above. It is guaranteed that each price in the bill is not less than one cent and not greater than 106 dollars.

Output

Print the total price exactly in the same format as prices given in the input.

Examples

Input

chipsy48.32televizor12.390


Output

12.438.32


Input

a1b2c3.38


Output

6.38


Input

aa0.01t0.03


Output

0.04

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.StringTokenizer;


public class sol {
	//...................... Global Variables .......................//
	static BitSet prime;             // used in seive generation
	// true = not prime     and false = prime
	int prev_avg = 0;
	int n = 0;
	//...................... Global Variables .......................//
	
	
	
	
	
	//===================  PROBLEM SOLVING COMES HERE ===== START  ====================//
	
    void solve() throws IOException, Exception {
      
		String[] s = in.next().split("[a-z]+");
		double dol =0;
		
		for(int i =1;i<s.length;i++){
			String str = s[i];
			int n=str.length();
			if(n>=3)
				if(str.charAt(n-3) == '.'){
					str= str.substring(0, n-3).replaceAll("\\.", "") + str.substring(n-3,n);	
				}else{
					str = str.replaceAll("\\.", "");
				}
			dol += Double.parseDouble(str);
		}
		long ll = (long) dol;
		dol = dol -(double)ll;
		dol = Math.round(dol*100)/100.0;
		String ss1 = Long.toString(ll);
		String ss2 = Double.toString(dol);
		
		
	//	out.println(ss1);
		int len =ss1.length();
		//System.out.println(len);
		String ss3="";
		int cnt =0;
		for(int i=len-1;i>=0;i--){
			if(cnt==3){
				ss3 +=".";
				cnt=0;
			}
			ss3 +=ss1.charAt(i);
			cnt++;
				
		}
			
			if(ss2.equals("0.0"))
				out.println(reverse(ss3));
			else if(ss2.length() == 3)
				out.println(reverse(ss3) + ss2.substring(1) + "0");
			else
				out.println(reverse(ss3) + ss2.substring(1));
		
		for(int i =0;i<s.length;i++){
			//System.out.println(s[i]);
		}
    }
    

    //===================  PROBLEM SOLVING COMES HERE ===== END ======================//
    
    
    
    
    
    
    public static void main(String[] args) throws FileNotFoundException, IOException, Exception {
    	
    	//--------------------------------- Console I/O ------------------------------//
    	   in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
           out = new PrintWriter(System.out);
    	//--------------------------------- Console I/O ------------------------------//
    	
    	
    	//--------------------------------- File I/O ---------------------------------//
        //   in = new FastScanner(new BufferedReader(new FileReader("input.txt")));
        //   out = new PrintWriter(new FileWriter("output.txt"));
        //--------------------------------- File I/O ---------------------------------//
        new sol().solve();
        out.close();
    }
    
    
    
    
    
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Useful Methods START ~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
    
    
	    double fact(double n){
			if(n==0||n==1)return 1;
			else return(n*fact(n-1));
		}
	    
		double nCr(double n,double r) {
			if(n==r)
				return 1;
			else
				return (fact(n)/(fact(r)*fact(n-r)));
		}
		
	// REverse a String
		String reverse(String s) {
			return new StringBuilder(s).reverse().toString();
		}
    
    //Modular Exponentiation
	    public static long modPow(long base,long power, long m)   // with mod
	    {  // long m = (long) 1e9+7;
	    	long  result = 1;
	    	if(power==0)  return 1;
	    	if(power==1)  return base;
	    	while(power>0)
	    	{
	    	    if(power%2==1)
	    	        result = (result * base) % m;
	    	    power = power >> 1;     // divide by 2
	    	    base = (base * base) % m;
	    	}
	    	return result;
	    } 
	    
	    public static long pow(long base,long power)              // without mod
	    { 
	    	long  result = 1;
	    	if(power==0)  return 1;
	    	if(power==1)  return base;
	    	while(power>0)
	    	{
	    	    if(power%2==1)
	    	        result = result * base;
	    	    power = power >> 1;     // divide by 2
	    	    base = base * base;
	    	}
	    	return result;
	    } 
	 // END Modular Exponentiation 
	    
	    
	 // GCD && LCM 
		public static long gcd(long a ,long b){ return b == 0 ? a : gcd(b , a % b); }
		public static long lcm(long a , long b){ return a*(b/gcd(a, b)); }   
		
	 // Count Number of One's in any number
		public static int countOnes(long n){ int count = 0;
			while(n>0){
				n = n & (n-1);
				count++;
			} return count; }
	
	//Pair Compare
		static class Pair implements Comparable<Pair>
		{
			int a,b;
			Pair (int a,int b)
			{
				this.a=a;
				this.b=b;
			}
		 
			public int compareTo(Pair o) {
				// TODO Auto-generated method stub
				if(this.a!=o.a)
				    return Integer.compare(this.a,o.a);
				else
					return Integer.compare(this.b, o.b);
				//return 0;
			}
			public boolean equals(Object o) {
		        if (o instanceof Pair) {
		            Pair p = (Pair)o;
		            return p.a == a && p.b == b;
		        }
		        return false;
		    }
		    public int hashCode() {
		        return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
		    }
		    
		} 
		
		
		
	 // Sieve of erothenese
		 public static void sieve(int UB){
			//ar = new ArrayList();
			  prime = new BitSet(UB+1);
			  prime.set(0);
			  prime.set(1);
			  for(int i = 2; i*i <= UB; i++){
				if(prime.get(i) == false){
					for(int j = i*i ; j <= UB ; j += i)
						prime.set(j);
				}
			  }
				/* for(int i = 2; i <= UB; i++){
				      if(!bs[i])ar.add(i);
				}*/
		 }
		 // usage hint : if prime.get(i)  == false    then  i is prime
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Useful Methods END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//

		 
		 
		 
		 
    static FastScanner in;
    static PrintWriter out;

    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;

        public FastScanner(BufferedReader in) {
            this.in = in;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() { return Integer.parseInt(nextToken()); }
        public long nextLong() { return Long.parseLong(nextToken()); }
        public double nextDouble() { return Double.parseDouble(nextToken()); }
        public BigInteger BigInteger()throws Exception { return new BigInteger(nextToken()); }
        public String next() throws IOException { return nextToken(); }
        public String nextLine() throws IOException { return in.readLine(); }
        
        public int[] readIntArray(int n) {
            int[] ret = new int[n];
            for (int i = 0; i < n; i++) {
                ret[i] = nextInt();
            }
            return ret;
        }
        
        public void printIntArray(int ar[],int n) {
            for (int i = 0; i < n; i++) {
                System.out.print(ar[i] +" ");
            }System.out.println();
        }
        
    }
}