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.io.*;
import java.util.*;

public class Template {

	String fileName = "";

	void solve() throws NumberFormatException, IOException {

		int n = readInt();
		
		if(n%10>5) {
			out.println(n+(10-(n%10)));
		}else {
			out.println(n - (n%10));
		}

	}

	class Fenwik {
		long[] t;
		int length;

		Fenwik(int[] a) {
			length = a.length + 100;
			t = new long[length];

			for (int i = 0; i < a.length; ++i) {
				inc(i, a[i]);
			}
		}

		void inc(int ind, int delta) {
			for (; ind < length; ind = ind | (ind + 1)) {
				t[ind] += delta;
			}
		}

		long getSum(int r) {
			long sum = 0;
			for (; r >= 0; r = (r & (r + 1)) - 1) {
				sum += t[r];
			}
			return sum;
		}
	}

	class SegmentTree {
		int[] t;

		SegmentTree(int[] a) {
			int n = a.length - 1;
			t = new int[n * 4];
			build(a, 1, 1, n);
		}

		void build(int[] a, int v, int tl, int tr) {
			if (tl == tr) {
				t[v] = a[tl];
				return;
			}

			int mid = (tr + tl) / 2;

			build(a, 2 * v, tl, mid);
			build(a, 2 * v + 1, mid + 1, tr);

			t[v] = Math.max(t[2 * v], t[2 * v + 1]);
		}

		void update(int v, int tl, int tr, int pos, int value) {
			if (tl == tr) {
				t[v] = value;
				return;
			}

			int mid = (tl + tr) / 2;

			if (pos <= mid) {
				update(2 * v, tl, mid, pos, value);
			} else {
				update(2 * v + 1, mid + 1, tr, pos, value);
			}

			t[v] = Math.max(t[2 * v], t[2 * v + 1]);
		}

		int getMax(int v, int tl, int tr, int l, int r) {
			if (l > r) {
				return -1000 * 1000;
			}
			if (tl == tr) {
				return t[v];
			}

			if (l == tl && r == tr) {
				return t[v];
			}

			int mid = (tl + tr) / 2;

			int max1 = getMax(2 * v, tl, mid, l, Math.min(mid, r));
			int max2 = getMax(2 * v + 1, mid + 1, tr, Math.max(mid + 1, l), r);

			return Math.max(max1, max2);
		}
	}

	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub
		new Template().run();
	}

	void run() throws NumberFormatException, IOException {
		solve();
		out.close();
	};

	BufferedReader in;
	PrintWriter out;

	StringTokenizer tok;
	String delim = " ";
	Random rnd = new Random();

	Template() throws FileNotFoundException {
		try {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		} catch (Exception e) {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}

		}
		tok = new StringTokenizer("");
	}

	String readLine() throws IOException {
		return in.readLine();
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine) {
				return null;
			}

			tok = new StringTokenizer(nextLine);
		}
		return tok.nextToken();
	}

	int readInt() throws NumberFormatException, IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws NumberFormatException, IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(readString());
	}
}