Problem: Vasya has a non-negative integer n. He wants to round it to nearest integer, which ends up with 0. If n already ends up with 0, Vasya considers it already rounded.

For example, if n = 4722 answer is 4720. If n = 5 Vasya can round it to 0 or to 10. Both ways are correct.

For given n find out to which integer will Vasya round it.

Input

The first line contains single integer n (0 ≤ n ≤ 109) — number that Vasya has.

Output

Print result of rounding n. Pay attention that in some cases answer isn't unique. In that case print any correct answer.

Examples

Input

5


Output

0


Input

113


Output

110


Input

1000000000


Output

1000000000


Input

5432359


Output

5432360

Note

In the first example n = 5. Nearest integers, that ends up with zero are 0 and 10. Any of these answers is correct, so you can print 0 or 10.

Solution (in JAVA):

Solution:

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

		
		
		
		
		/*
		 * 
		 * daiict
		 *
		 * 
		 * 
		 */
		
		
		public class Main {
			FastScanner in;
			PrintWriter out;
		
			static ArrayList[] adj;
			
			static int n;
			static int m;
			static int visited[][];
			static int[][] arr;
			static int[][] brr;
			static int[][] ans;
			static int array[];
			static int pref[];
			static int sum = 0;
		//for dfs do not delete
			static int dir[][] ={{-2,-1},{-2,1},{0,2},{2,1},{2,-1},{0,-2}};
			
			static long[] tree;
			static long[] lazy;
			static int a,b,c,d;
			static long an = 0;
			static long bn = 0;
			static int p = 0;
			static int ta = -1;
			static int tb = -1;
			static Stack<Integer> st;
			static int k;
			static long mod = (long)1e9;
			static long[] seg;
			
			static int num = Integer.MAX_VALUE;
			static String str;
			
			static class Pair implements Comparable<Pair>
		    {
				int x;
				boolean y;
				String s = "";
				String val;
		        Pair(int l, boolean b, String p,String q) {
		          
		        	this.x = l;
		            this.y = b;
		           this.s = p;
		           this.val = q;
		        }
		        @Override
		        public int compareTo(Pair p) {
		        	
		        	String arr[] = val.split(" ");
		        	String brr[] = p.val.split(" ");
		        	
		        	if(s.equals("numeric")){
		        		int aa = Integer.parseInt(arr[x]);
						int bb = Integer.parseInt(brr[x]);
						
						if(aa>bb && this.y){
							return 1;
						}else if(this.y){
							return -1;
						}else if(aa >= bb && ! this.y){
							return -1;
						}else{
							return 1;
						}
		        	}else{
		        		if(this.y){
		        			return arr[x].compareTo(brr[x]);
		        		}else{
		        			return brr[x].compareTo(arr[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.min(seg[i<<1],seg[i<<1|1]);
				}

			public static void modify(int p, long val,int n) {  // set value at position p
				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.min(seg[p],seg[p^1]);
				}

				long query(int l, int r,int n) {  // sum on interval [l, r)
				  long res = Long.MAX_VALUE;
				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
				    if ((l&1) == 1) res = (long) Math.min(res,seg[l++]);
				    if ((r&1) == 1) res = (long)Math.min(res,seg[--r]);
				  }
				  return res;
				}

				 static long bC(int n, int k)
				    {
				    long C[][] = new long[n+1][k+1];
				    int i, j;
				     
				        // Calculate  value of Binomial Coefficient in bottom up manner
				    for (i = 0; i <= n; i++)
				    {
				        for (j = 0; j <= Math.min(i, k); j++)
				        {
				            // Base Cases
				            if (j == 0 || j == i)
				                C[i][j] = 1;
				      
				            // Calculate value using previosly stored values
				            else
				                C[i][j] = C[i-1][j-1] + C[i-1][j];
				          }
				     }
				      
				    return C[n][k];
				    }
				
		    void solve() throws NumberFormatException, IOException {
		 
		    	StringBuilder sb = new StringBuilder();
		    	Scanner in = new Scanner(System.in);
		    	
		    	int n = in.nextInt();
		    	
		    	int b = n/10;
		    	int c = n%10;
		    	
		    	if(c>5){
		    		b++;
		    	}
		    	
		    	out.println(b*10);
		    	
		    }
		    
		    int call(int a,ArrayList<Integer> list){
		    	int l = 0;
		    	int r = list.size();
		    	if(r != 0 && list.get(0) > a){
		    		return r-1;
		    	}
		    	
		    	while(l!=r){
		    	//	out.println(l + " " + r);
		    		int mid = (l+r)>>1;
		    		if(list.get(mid) <= a){
		    			l = mid+1;
		    		}else{
		    			r = mid;
		    		}
		    	}
		    	
		    	return --l;
		    		    	
		    }
		    
		    int call2(int a,ArrayList<Integer> list){
		    	int l = 0;
		    	int r = list.size();
		    	if(r != 0 && list.get(r-1) < a){
		    		return 0;
		    	}
		    	
		    	while(l!=r){
		    	//	out.println(l + " " + r);
		    		int mid = (l+r)>>1;
		    		if(list.get(mid) < a){
		    			l = mid+1;
		    		}else{
		    			r = mid;
		    		}
		    	}
		    	
		    	return l;
		    		    	
		    }
		    
		    void buildSegTree(long[] arr, int treeIndex, int lo, int hi)
		    {
		        if (lo == hi) {                 // leaf node. store value in node.
		            tree[treeIndex] = arr[lo];
		            return;
		        }

		        int mid = lo + (hi - lo) / 2;   // recurse deeper for children.
		        buildSegTree(arr, 2 * treeIndex + 1, lo, mid);
		        buildSegTree(arr, 2 * treeIndex + 2, mid + 1, hi);

		        // merge build results
		        tree[treeIndex] = (tree[2 * treeIndex + 1] + tree[2 * treeIndex + 2]);
		    }
		   		    
		    long queryLazySegTree(int treeIndex, int lo, int hi, int i, int j)
		    {
		        // query for arr[i..j]

		        if (lo > j || hi < i)                                   // segment completely outside range
		            return 0;                                           // represents a null node

		        if (lazy[treeIndex] != 0) {                             // this node is lazy
		            tree[treeIndex] += (hi - lo + 1) * lazy[treeIndex]; // normalize current node by removing laziness

		            if (lo != hi) {                                     // update lazy[] for children nodes
		                lazy[2 * treeIndex + 1] += lazy[treeIndex];
		                lazy[2 * treeIndex + 2] += lazy[treeIndex];
		            }

		            lazy[treeIndex] = 0;                                // current node processed. No longer lazy
		        }

		        if (i <= lo && j >= hi)                                 // segment completely inside range
		            return tree[treeIndex];

		        int mid = lo + (hi - lo) / 2;                           // partial overlap of current segment and queried range. Recurse deeper.

		        if (i > mid)
		            return queryLazySegTree(2 * treeIndex + 2, mid + 1, hi, i, j);
		        else if (j <= mid)
		            return queryLazySegTree(2 * treeIndex + 1, lo, mid, i, j);

		        long leftQuery = queryLazySegTree(2 * treeIndex + 1, lo, mid, i, mid);
		        long rightQuery = queryLazySegTree(2 * treeIndex + 2, mid + 1, hi, mid + 1, j);

		        // merge query results
		        return leftQuery + rightQuery;
		    }
		    
		    void updateLazySegTree(int treeIndex, int lo, int hi, int i, int j, int val)
		    {
		        if (lazy[treeIndex] != 0) {                             // this node is lazy
		            tree[treeIndex] += (hi - lo + 1) * lazy[treeIndex]; // normalize current node by removing laziness

		            if (lo != hi) {                                     // update lazy[] for children nodes
		                lazy[2 * treeIndex + 1] += lazy[treeIndex];
		                lazy[2 * treeIndex + 2] += lazy[treeIndex];
		            }

		            lazy[treeIndex] = 0;                                // current node processed. No longer lazy
		        }

		        if (lo > hi || lo > j || hi < i)
		            return;                                             // out of range. escape.

		        if (i <= lo && hi <= j) {                               // segment is fully within update range
		            tree[treeIndex] += (hi - lo + 1) * val;             // update segment

		            if (lo != hi) {                                     // update lazy[] for children
		                lazy[2 * treeIndex + 1] += val;
		                lazy[2 * treeIndex + 2] += val;
		            }

		            return;
		        }

		        int mid = lo + (hi - lo) / 2;                             // recurse deeper for appropriate child

		        updateLazySegTree(2 * treeIndex + 1, lo, mid, i, j, val);
		        updateLazySegTree(2 * treeIndex + 2, mid + 1, hi, i, j, val);

		        // merge updates
		        tree[treeIndex] = tree[2 * treeIndex + 1] + tree[2 * treeIndex + 2];
		    }
		   
		    
		    public static int Floor(int[] dp, int low, int high, long x)
		    {
		        // If low and high cross each other
		        if (low > high)
		            return -1;

		        // If last element is smaller than x
		        if (x >= dp[high])
		            return high;

		        // Find the middle point
		        int mid = (low+high)/2;

		        // If middle point is floor.
		        if (dp[mid] == x)
		            return mid;

		        // If x lies between mid-1 and mid
		        if (mid > 0 && dp[mid-1] <= x && x < dp[mid])
		            return mid-1;

		        // If x is smaller than mid, floor must be in
		        // left half.
		        if (x < dp[mid])
		            return Floor(dp, low, mid-1, x);

		        // If mid-1 is not floor and x is greater than
		        // arr[mid],
		        return Floor(dp, mid+1, high, x);
		    }
		    
		
		    public static String[] reverse(String arr[]){
		    	
		    	
		    	for(int i = 0;i<arr.length/2;i++){
		    		String temp = arr[i];
		    		arr[i] = arr[arr.length-i-1];
		    		arr[arr.length-1-i] = temp;
		    	}
		    	
		    	return arr;
		    	
		    }
			
		    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 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);
			}
		
			
			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(long n2) {
				// Corner cases
				if (n2 <= 1)
					return false;
				if (n2 <= 3)
					return true;
		 
				// This is checked so that we can skip 
				// middle five numbers in below loop
				if (n2 % 2 == 0 || n2 % 3 == 0)
					return false;
		 
				for (int i = 5; i * i <= n2; i = i + 6)
					if (n2 % i == 0 || n2 % (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());
				}
			}
			
			class Tri{
				
				Tri[] arr;
				
				public Tri(){
					arr = new Tri[27];
				}
				
			}
			
			
		 
		
			public static void main(String[] args) throws NumberFormatException, IOException {
				new Main().run();
			}
		}
		
		
		class Node{
			int a;
			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<String>{
		    
			int c = 0;
			
			MyComp2(int d){
				c = d;
			}
			
			@Override
			public int compare(String a,String b) {
				
				// < == -1
				
				String arr[] = a.split(" ");
				String brr[] = b.split(" ");
				
				int aa = Integer.parseInt(arr[c]);
				int bb = Integer.parseInt(brr[c]);
				
				if(aa>bb){
					return 1;
				}else{
					return -1;
				}
				
				
			}

			
		}