Problem: Pari has a friend who loves palindrome numbers. A palindrome number is a number that reads the same forward or backward. For example 12321, 100001 and 1 are palindrome numbers, while 112 and 1021 are not.

Pari is trying to love them too, but only very special and gifted people can understand the beauty behind palindrome numbers. Pari loves integers with even length (i.e. the numbers with even number of digits), so she tries to see a lot of big palindrome numbers with even length (like a 2-digit 11 or 6-digit 122221), so maybe she could see something in them.

Now Pari asks you to write a program that gets a huge integer n from the input and tells what is the n-th even-length positive palindrome number?

Input

The only line of the input contains a single integer n (1 ≤ n ≤ 10100 000).

Output

Print the n-th even-length palindrome number.

Examples

Input

1


Output

11


Input

10


Output

1001

Note

The first 10 even-length palindrome numbers are 11, 22, 33, ... , 88, 99 and 1001.

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

public class Solution{
	public Solution(){
		Scanner sc = new Scanner(System.in);
		String n = sc.next();
		byte[] strArr = n.getBytes();
		byte[] strRevArr = new byte[strArr.length];
		
		for(int i=0; i<strArr.length; i++){
			strRevArr[i] = strArr[strArr.length-1-i];
		}
		
		String res = new String(strRevArr);
		res = n + res;
		System.out.println(res);
	}
	
	int binarySearch(int arr[], int l, int r, int x) 
    { 
        if (r >= l) { 
            int mid = l + (r - l) / 2; 
  
            // If the element is present at the 
            // middle itself 
            if (arr[mid] == x) 
                return mid; 
  
            // If element is smaller than mid, then 
            // it can only be present in left subarray 
            if (arr[mid] > x) 
                return binarySearch(arr, l, mid - 1, x); 
  
            // Else the element can only be present 
            // in right subarray 
            return binarySearch(arr, mid + 1, r, x); 
        } 
  
        // We reach here when element is not present 
        // in array 
        return -1; 
    }
	
	int partition(int arr[], int[] dep, int low, int high) 
    { 
        int pivot = arr[high];  
        int i = (low-1); // index of smaller element 
        for (int j=low; j<high; j++) 
        { 
            // If current element is smaller than or 
            // equal to pivot 
            if (arr[j] <= pivot) 
            { 
                i++; 
  
                // swap arr[i] and arr[j] 
                int temp = arr[i]; 
                arr[i] = arr[j]; 
                arr[j] = temp;
				
				if(dep != null){
					temp = dep[i];
					dep[i] = dep[j];
					dep[j] = temp;
				}
            } 
        } 
  
        // swap arr[i+1] and arr[high] (or pivot) 
        int temp = arr[i+1]; 
        arr[i+1] = arr[high]; 
        arr[high] = temp;
		
		if(dep != null){
			temp = dep[i+1];
			dep[i+1] = dep[high];
			dep[high] = temp;
		}
  
        return i+1; 
    } 
  
  
    /* The main function that implements QuickSort() 
      arr[] --> Array to be sorted, 
      low  --> Starting index, 
      high  --> Ending index */
    void sort(int arr[], int[] dep, int low, int high) 
    { 
        if (low < high) 
        { 
            /* pi is partitioning index, arr[pi] is  
              now at right place */
            int pi = partition(arr, dep, low, high); 
  
            // Recursively sort elements before 
            // partition and after partition 
            sort(arr, dep, low, pi-1); 
            sort(arr, dep, pi+1, high); 
        } 
    }
	
	public static void main(String[] args){
		new Solution();
	}
}