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.
#def sumOfDivisors(n):
#    ans=0
#    i=1
#    while(i<=n):
#        r=n//(n//i)
#        ans+=(n//i)*((r*(r+1))//2-i*(i-1)//2)
#        i=r+1
#    ans-=n+(n*(n+1)//2-1)
#    return ans
#n=1000000000000
#print(sumOfDivisors(n))
from random import*
#def rob(nums):
#        if len(nums) == 0:
#            return 0
#        if len(nums) <= 3:
#            return max(nums)
#        one,two = 0,0
#        for i in nums[1:len(nums)]:
#            temp = max(one + i,two)
#            one = two
#            two = temp
#        one = max(one,two)
#        three = 0
#        two = 0
#        for i in nums[0:len(nums) - 1]:
#            temp = max(three + i,two)
#            three = two
#            two = temp
#        three = max(three,two)
#        return max(one,three)
#def numRookCaptures(board):
#	# find coordinates of rook(x,y)
#        for i in range(8):
#            for j in range(8):
#                if board[i][j]=='R':
#                    x=i
#                    y=j
#                    break
#        out=0
#		# Check the rook's row left and right,till it finds a bishop or board ends.
#		# If a pawn is found on either side,increase capture number by one.
#        if x>0:
#            i=x
#            while i>=0 and board[i][y]!='B':
#                if board[i][y]=='p':
#                    out+=1
#                    break
#                else:
#                    i-=1
#        if x<7:
#            i=x
#            while i<=7 and board[i][y]!='B':
#                if board[i][y]=='p':
#                    out+=1
#                    break
#                else:
#                    i+=1
#		#now check the rook's column up and down,same as before
#        if y>0:
#            j=y
#            while j>=0 and board[x][j]!='B':
#                if board[x][j]=='p':
#                    out+=1
#                    break
#                else:
#                    j-=1
#        if y<=7:
#            j=y
#            while j<=7 and board[x][j]!='B':
#                if board[x][j]=='p':
#                    out+=1
#                    break
#                else:
#                    j+=1
#        return out
#a=[[0]*8]*8
#s=".Bp"
#a[3][5]='R'
#for i in range(0,8):
#    for j in range(0,8):
#        if i!=3 and j!=5:
#            a[i][j]=s[int(random()*3)]
#print(a)
#print(numRookCaptures(a))
#def compute(triangle):
#	for i in reversed(range(len(triangle) - 1)):
#		for j in range(len(triangle[i])):
#			triangle[i][j] += max(triangle[i + 1][j], triangle[i + 1][j + 1])
#	return str(triangle[0][0])
#n=int(input())
#triangle=[0]*n
#for i in range(0,n):
#	triangle[i]=[0]*(i+1)
#for i in range(0,n):
#	for j in range(0,i+1):
#		triangle[i][j]=int(random()*1000)
#print(triangle)
#print(compute(triangle))
#def matrixBlockSum(x,k):
#        m,n=len(x),len(x[0])
#        y=[[x[i][0]] for i in range(m)]
#        for i in range(m):
#            for j in range(1,n):
#                y[i].append(y[i][-1]+x[i][j])
#        z=[[0 for i in range(n)] for i in range(m)]
#        z[0]=y[0]
#        for i in range(1,m):
#            for j in range(n):
#                z[i][j]=z[i-1][j]+y[i][j]
#        x=z
#        y=[[0 for i in range(n)] for j in range(m)]
#        for i in range(m):
#            for j in range(n):
#                a,b,c,d=max(0,i-k),max(0,j-k),min(m-1,i+k),min(n-1,j+k)
#                a-=1;b-=1
#                y[i][j]=x[c][d] - (0 if b==-1 else x[c][b])+(0 if a==-1 or b==-1  else x[a][b])-(0 if a==-1 else x[a][d] )
#        return y
#n,m=map(int,input().split())
#k=int(input())
#a=[[0]*m]*n
#for i in range(n):
#    for j in range(m):
#        a[i][j]=int(random()*10000)
#print(a)
#print(matrixBlockSum(a,1))
#def bellNumber(n): 
  
#    bell = [[0 for i in range(n+1)] for j in range(n+1)] 
#    bell[0][0] = 1
#    for i in range(1, n+1): 
  
#        # Explicitly fill for j = 0 
#        bell[i][0] = bell[i-1][i-1]%(10**9+7)
  
#        # Fill for remaining values of j 
#        for j in range(1, i+1): 
#            bell[i][j] = (bell[i-1][j-1] + bell[i][j-1] )%(10**9+7)
  
#    return bell[n][0]%(10**9+7)
#n=int(input())
#print(bellNumber(30))
from random import*
def summaryRanges(nums):
        if len(nums)==0:
            return []
        res=[]
        Count=0
        for i in range(1,len(nums)):
            if nums[i]!=nums[i-1]+1:
                if i-1!=Count:
                    res.append(str(nums[Count])+'->'+str(nums[i-1]))
                else:
                    res.append(str(nums[i-1]))
                Count=i
        i=len(nums)
        if i-1!=Count:
            res.append(str(nums[Count])+'->'+str(nums[i-1]))
        else:
            res.append(str(nums[i-1]))
        return res
def canMeasureWater(x: int, y: int, z: int) -> bool:
        if x>y: x,y=y,x
        def gcd(a,b):
            if b==0:
                return a
            else:
                return gcd(b,a%b)
        ans=gcd(y,x)
        if ans==0: return z==0
        return (x+y)>=z and z%ans==0
def gcd(a, b): 
    if b==0: 
        return a 
    return gcd(b, a%b) 
  
  
''' fromCap -- Capacity of jug from which 
              water is poured 
   toCap   -- Capacity of jug to which 
              water is poured 
   d       -- Amount to be measured '''
def Pour(toJugCap, fromJugCap, d): 
  
  
    # Initialize current amount of water 
    # in source and destination jugs 
    fromJug = fromJugCap 
    toJug  = 0
  
    # Initialize steps required 
    step = 1
    while ((fromJug  is not d) and (toJug is not d)): 
  
          
        # Find the maximum amount that can be 
        # poured 
        temp = min(fromJug, toJugCap-toJug) 
  
        # Pour 'temp' liter from 'fromJug' to 'toJug' 
        toJug = toJug + temp 
        fromJug = fromJug - temp 
  
        step =  step + 1
        if ((fromJug == d) or (toJug == d)): 
            break
  
        # If first jug becomes empty, fill it 
        if fromJug == 0: 
            fromJug = fromJugCap 
            step =  step + 1
  
        # If second jug becomes full, empty it 
        if toJug == toJugCap: 
            toJug = 0
            step =  step + 1
              
    return step 
  
# Returns count of minimum steps needed to 
# measure d liter 
def minSteps(n, m, d): 
    if m> n: 
        temp = m 
        m = n 
        n = temp 
          
    if (d%(gcd(n,m)) is not 0): 
        return -1
      
    # Return minimum two cases: 
    # a) Water of n liter jug is poured into 
    #    m liter jug 
    return(min(Pour(n,m,d), Pour(m,n,d))) 
  
# Driver code 

from random import*
# Find the number of covered side for mat[i][j]. 
def numofneighbour(mat, i, j,R,C): 
  
    count = 0; 
  
    # UP 
    if (i > 0 and mat[i - 1][j]): 
        count+= 1; 
  
    # LEFT 
    if (j > 0 and mat[i][j - 1]): 
        count+= 1; 
  
    # DOWN 
    if (i < R-1 and mat[i + 1][j]): 
        count+= 1
  
    # RIGHT 
    if (j < C-1 and mat[i][j + 1]): 
        count+= 1; 
  
    return count; 
  
# Returns sum of perimeter of shapes formed with 1s 
def findperimeter(mat): 
  
    perimeter = 0; 
    R=len(mat)
    C=len(mat[0])
    # Traversing the matrix and finding ones to 
    # calculate their contribution. 
    for i in range(0, R): 
        for j in range(0, C): 
            if (mat[i][j]): 
                perimeter += (4 - numofneighbour(mat, i, j,R,C)); 
  
    return perimeter; 
def maxNumberOfBalloons(text: str, check:str) -> int:
    a=[0]*26
    for i in text:
        a[ord(i)-97]+=1
    Min=10000
    Count=1
    check=sorted(check)
    for i in range(1,len(check)):
        if check[i]!=check[i-1]:
            Min=min(Min,a[ord(check[i-1])-97]//Count)
            Count=1
        else:
            Count+=1
    Min=min(Min,a[ord(check[len(check)-1])-97]//Count)
    return Min
# Driver Code 
#rand="abcdefghijklmnopqrstuvwxyz"
#str=""
#word=""
#for i in range(0,int(random()*50+99950)):
#    str+=rand[int(random()*26)]
#for i in range(0,int(random()*3+6)):
#    word+=rand[int(random()*26)]
#print(str)
#print(word)
#print(maxNumberOfBalloons(str,word))
def Solve(s):
    check=[]
    for i in range(1,len(s)-1):
        if s[i]!=' ' and s[i]!=',':
                check.append(s[i])
    return len(set(check))
def lastStoneWeightII(stones) -> int:                           
    half_sum = sum(stones) // 2
       
    dp = [[False for _ in range(half_sum + 1)] for _ in range(len(stones))]    
        
    for s in range(half_sum+1):
        dp[0][s] = stones[0] == s
          
    for i in range(len(stones)):
        dp[i][0] = True   
        
    for i in range(1, len(stones)):
        for s in range(1, half_sum + 1):             
            take_stone, leave_stone = False, False
            if stones[i] <= s:
                take_stone = dp[i-1][s-stones[i]]
            leave_stone = dp[i-1][s]
            dp[i][s] = take_stone or leave_stone
        
    for s in range(half_sum, -1, -1):
        if dp[-1][s]:    
             return abs(sum(stones) - 2 * s)
#CountB,CountW=0,0
#dict={}
#a=[]
#dict['q']=9
#dict['r']=5
#dict['b']=3
#dict['k']=0
#dict['p']=1
#dict['n']=3
#for i in range(8):
#    s=str(input())
#    a.append(s)
#    for j in s:
#        if j!='.' and j.upper()==j:
#            CountW+=dict[j.lower()]
#        elif j!='.' and j.lower()==j:
#            CountB+=dict[j.lower()]
n=str(input())
print(n+n[::-1])