Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer). 

There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.

In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.

For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.

Input

The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.

The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.

Output

Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.

Examples

Input

6 1
10.245


Output

10.25


Input

6 2
10.245


Output

10.3


Input

3 100
9.2


Output

9.2

Note

In the first two samples Efim initially has grade 10.245. 

During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.

In the third sample the optimal strategy is to not perform any rounding at all.
import java.util.*;
import java.io.*;
import java.math.*;
public final class Solution 
{
	static ArrayList<ArrayList<Integer>> adj = new ArrayList<>(); //adjacency list of graph
	static boolean[] visited; //array visited of nodes of graph
    public static void main(String[] args)
    {
   	 Reader input = new Reader();
     PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
     int n = input.nextInt(), t = input.nextInt();
     char[] arr = input.next().toCharArray();
     int dotIndex = 0;
     for(int i = 0 ; i < n ; i++)
     {
    	 if(arr[i] == '.')
    	 {
    		 dotIndex = i;
    		 break;
    	 }
     }
     int first = -1;
     for(int i = dotIndex + 1 ; i < n ; i++)
     {
    	 if(arr[i] >= '5')
    	 {
    		 first = i;
    		 break;
    	 }
     }
     if(first == -1)
     {
    	 for(int i = 0 ; i < n ; i++)
    		 out.print(arr[i]);
     }
     for(int i = first ; i > dotIndex + 1 ; i--)
     {
    	 if(arr[i] >= '5' && t != 0)
    	 {
    		 t--;
    		 arr[i] = 'x';
    		 if(arr[i-1] == '9')
    		 {
    			 int temp = i-1;
    			 while(arr[temp] == '9' && temp > dotIndex)
    			 {
    				 arr[temp--] = 'x';
    			 }
    			 if(temp == dotIndex)
    			 {
    				 arr[dotIndex] = 'x';
    				 arr[dotIndex+1] = 'x';
    				 if(arr[dotIndex - 1] == '9')
    				 {
    					 int temp2 = dotIndex - 1;
    	    			 while(arr[temp2] == '9' && temp2 >= 0)
    	    			 {
    	    				 arr[temp2--] = '0';
    	    			 }
    	    			 if(temp2 == -1)
    	    			 {
    	    				 out.print(1);
    	    				 for(int j = 0 ; j < first ; j++)
    	    				 {
    	    					 if(arr[j] != 'x')
    	    						 out.println(arr[j]);
    	    				 }
    	    				 out.close();
    	    				 return;
    	    			 }
    	    			 else
    	    			 {
    	    				 arr[temp2] = (char)(arr[temp2] + 1);
    	    			 }
    				 }
    				 else
    					 arr[dotIndex-1] = (char)(arr[dotIndex-1] + 1);
    			 }
    			 else
    			 {
    				 arr[temp] = (char)(arr[temp] + 1);
    			 }
    		 }
    		 else
    			 arr[i-1] = (char)(arr[i-1] + 1);
    	 }
    	 else
    		 break;
     }
     if(t != 0 && arr[dotIndex+1] >= '5')
     {
		 arr[dotIndex] = 'x';
		 arr[dotIndex+1] = 'x';
    	 if(arr[dotIndex - 1] == '9')
    	 {
			 int temp2 = dotIndex - 1;
			 while(temp2 >= 0 && arr[temp2] == '9')
			 {
				 arr[temp2--] = '0';
			 }
			 if(temp2 == -1)
			 {
				 out.print(1);
				 for(int j = 0 ; j < first ; j++)
				 {
					 if(arr[j] != 'x')
						 out.print(arr[j]);
				 }
				 out.close();
				 return;
			 }
			 else
			 {
				 arr[temp2] = (char)(arr[temp2] + 1);
			 }
    	 }
    	 else
    	 {
    		 arr[dotIndex-1] = (char)(arr[dotIndex-1] + 1);
    	 }
     }
     for(int i = 0 ; i < first ; i++)
     {
    	 if(arr[i] != 'x')
    	 {
    		 out.print(arr[i]);
    	 }
     }
     out.close();	 
    }  
	public static void bfs(int start) 
	{		
		ArrayList<Integer> queue = new ArrayList<>();
		queue.add(start);
		while(queue.size() != 0)
		{
			int node = queue.get(0);
			queue.remove(0);
			if(visited[node])
				continue;
			visited[node] = true;
			/*do something here with variable node if needed*/
			for(int i = 0 ; i < adj.get(node).size(); i++)
				queue.add(adj.get(node).get(i));
		}
	}

	public static int stronglyConnectedComponents() 
	{
		int count = 0;
		for(int i = 0 ; i < adj.size(); i++)
		{
			if(!visited[i])				
			{
				count++;
				dfs(i);
			}
		}
		return count;
	}
	public static void dfs(int start) 
	{
		/*do something here with the node(start) if needed*/
		visited[start] = true;
		for(int i = 0 ; i < adj.get(start).size(); i++)
		{
			if(visited[adj.get(start).get(i)])
				continue;			
			dfs(adj.get(start).get(i));
		}
	}
    public static int z(int n)
    {
    	/*finds the number of trailing zeros in factorial */
    	int count = 0;
    	for(int i = 5 ; i <= n ; i *= 5)
    	{
    		count += n / i;
    	}
    	return count;
    }
    public static int gcd(int a , int b)
    {
    	if(b == 0)
    		return a;
    	return gcd(b , a %b);
    }
    public static class UnionFind
    {
    	/* this class uses zeroIndexing and gives the result back in zero indexing*/
    	int[] parent;
    	int[] size;
    	int maxSize = 0;
    	public UnionFind(int n)
    	{
    		size = new int[n];
    		parent = new int[n];
    		for(int i = 0 ; i < n ; i++)
    		{
    			parent[i] = i;
    			size[i] = 1;
    		}
    		maxSize = 1;
    	}
    	public int find(int pos)
    	{
    		if(parent[pos] == pos)
    			return pos;
    		return parent[pos] = find(parent[pos]);
    	}
    	public void unify(int x , int y)
    	{
    		int xParent = find(x);
    		int yParent = find(y);
    		if(xParent == yParent)
    			return;
    		else if(size[xParent] > size[yParent]) 
    		{
    			size[xParent] += size[yParent];
    			if(size[xParent] > maxSize)
    				maxSize = size[xParent];
    			parent[yParent] = xParent;
    		}
    		else
    		{
    			size[yParent] += size[xParent];
    			if(size[yParent] > maxSize)
    				maxSize = size[yParent];
    			parent[xParent] = yParent;
    		}
    	}
    	public int maxSize()
    	{
    		return maxSize;
    	}
    	public int connectedComponents()
    	{
    		int count = 0;
    		for(int i = 0 ; i < parent.length ; i++)
    		{
    			if(i == parent[i])
    				count++;
    		}
    		return count;
    	}
    }
    public static class Pair implements Comparable<Pair>
    {
    	int a ,  b;
    	public Pair(int a , int b)
    	{
    		this.a = a;
    		this.b = b;
    	}
		@Override
		public int compareTo(Pair t) {
			// TODO Auto-generated method stub
    		if(t.a == this.a)
    		{
    			if(this.b < t.b)
    				return -1;
    			else if(this.b > t.b)
    				return 1;
    			else
    				return 0;
    		}
    		else if(this.a < t.a)
    			return -1;
    		else
    			return 1;
		}
    }
    public static class Reader
    {
    	BufferedReader br;
    	StringTokenizer st;
    	public Reader()
    	{
    		br = new BufferedReader(new InputStreamReader(System.in));    		
    	}
    	public String next()
    	{
    		try
    		{
        		if(st == null || !st.hasMoreTokens())
        			st = new StringTokenizer(br.readLine());
    		}
    		catch(IOException ex)
    		{
    			ex.printStackTrace();
    			System.exit(1);
    		}    		
    		return st.nextToken();
    	}
    	public int nextInt()
    	{
    		return Integer.parseInt(next());
    	}
    	public double nextDouble()
    	{
    		return Double.parseDouble(next());
    	}
    	public long nextLong()
    	{
    		return Long.parseLong(next());
    	}
    	public String nextLine()
    	{
    		try
    		{
    			return br.readLine();
    		}
    		catch(IOException ex)
    		{
    			ex.printStackTrace();
    			System.exit(1);
    		}
    		return "";
    	}
    }
}