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 ≤ 10^{100 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.

Source: codeforces | Difficulty: EASY
Tags: Mathematics

Constructive algorithms


Solutions:
from collections import deque
n = input()
p = deque()
for i in range(len(n) - 1, -1, -1):
	d = n[i]
	p.append(d)
	p.appendleft(d)
print(''.join(p))


s = input()
print(s + s[::-1])


import sys
n = input()
print(n + n[::-1])


a = input()
n = len(a)
b = ''
for i in range(0, n):
	b += a[n - i - 1]
print(a + b)


n = input()
print(n, str(n)[::-1], sep='')


i = list(map(int, input()))
g = i[:]
g.reverse()
p = i + g
print(''.join([str(elem) for elem in p]))


n = input()
print(n + n[::-1])


current_s = input()
print(current_s + current_s[::-1])


from sys import stdin, stdout
from collections import defaultdict
import heapq as hq

def get_int():
	return int(stdin.readline().strip())

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_array():
	return list(map(int, stdin.readline().strip().split()))

def get_string():
	return stdin.readline().strip()
INF = 10000000000.0
s = get_string()
a = list(reversed(s))
print(s, end='')
for i in a:
	print(i, end='')


x = input()
print(x, end='')
for i in x[::-1]:
	print(i, end='')


n = str(input())
a = list(n)
a.reverse()
print(n + ''.join(a))


l = input()
print(l, end='')
print(l[::-1])


l = list(input())
print(*l + list(reversed(l)), sep='')


n = input()
print(f'{n}{n[::-1]}')


str_ = input()
print(str_ + str_[::-1])


a = input()
b = ''.join(reversed(a))
print(a + b)


N = input()
print(N + N[::-1])


import sys
import math
input = sys.stdin.readline
s = input().strip()
print(s + s[::-1])


s_t_r = input()
print(s_t_r + ''.join(s_t_r[::-1]))


num = str(input())
print(num + num[::-1])


x = input()
y = x[-1::-1]
z = x + y
print(z)


import sys, string
n = sys.stdin.readline().strip()
sys.stdout.write(str(n + n[::-1]))


m = str(input())
n = m[::-1]
ans = m + n
print(ans)


str = input()
reverse = str[-1::-1]
print(str + reverse)


string = str(input())
print(string, end='')
strina = string[::-1]
print(strina, end='')


import sys
input = sys.stdin.readline().strip
n = input()
print(n + n[::-1])


n = int(input())
s = str(n)
print(s + s[::-1])


x = input()
if len(x) % 2 == 0:
	t = x[::-1]
	print(x + t)
else:
	print(x + x[::-1])


n = input()
k = n + n[::-1]
print(k)


string = input()
ans = string + string[::-1]
print(ans)


n = input()
print(n + ''.join(reversed(list(n))))


n = int(input())
n = str(n)
q = str(n[::-1])
qq = n + q
print(qq)


from sys import stdin, stdout
from sys import maxsize
input = stdin.readline

def solve():
	pass

def log(n):
	ans = 0
	val = 1
	while val < n:
		ans += 1
		val *= 10
	return (ans - 1, val // 10)
test = 1
for t in range(0, test):
	n = int(input().strip())
	ans = str(n)
	print(ans + ans[::-1])
	ans = solve()


a = input()
print(a, end='')
a = str(a)
for i in range(len(a) - 1, -1, -1):
	print(a[i], end='')


pos = input()
print(pos + pos[::-1])


num = input()
new = ''
for i in range(len(num)):
	new = num[i] + new
print(num + new)


st = input()
print(st, st[::-1], sep='')


n = input()
print(n, end='')
print(n[::-1])


n = int(input())
N = str(n)
print(N + N[::-1])


from random import *
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)

def Pour(toJugCap, fromJugCap, d):
	fromJug = fromJugCap
	toJug = 0
	step = 1
	while fromJug is not d and toJug is not d:
		temp = min(fromJug, toJugCap - toJug)
		toJug = toJug + temp
		fromJug = fromJug - temp
		step = step + 1
		if fromJug == d or toJug == d:
			break
		if fromJug == 0:
			fromJug = fromJugCap
			step = step + 1
		if toJug == toJugCap:
			toJug = 0
			step = step + 1
	return step

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 min(Pour(n, m, d), Pour(m, n, d))
from random import *

def numofneighbour(mat, i, j, R, C):
	count = 0
	if i > 0 and mat[i - 1][j]:
		count += 1
	if j > 0 and mat[i][j - 1]:
		count += 1
	if i < R - 1 and mat[i + 1][j]:
		count += 1
	if j < C - 1 and mat[i][j + 1]:
		count += 1
	return count

def findperimeter(mat):
	perimeter = 0
	R = len(mat)
	C = len(mat[0])
	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

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)
n = str(input())
print(n + n[::-1])


temp = input()
print(temp + temp[::-1])


n = input()
a = n
for x in range(len(n) - 1, -1, -1):
	a += n[x]
print(a)


l = list(input())
n = len(l)
for i in range(1, n + 1):
	l.append(l[n - i])
print(*l, sep='')


def ProblemB():
	n = input()
	x = n
	x = x + n[::-1]
	print(x)
ProblemB()


n = input()
res = n
l = len(n)
for i in range(l - 1, -1, -1):
	res += n[i]
print(res)


n = str(input())
if len(n) == 1:
	print(n + n)
else:
	print(n + n[::-1])


import sys
s = input()
print(s, end='')
print(s[::-1])


def favourite(s):
	result = ''
	for i in range(len(s)):
		result += s[i]
	for i in range(len(s) - 1, -1, -1):
		result += s[i]
	return result
print(favourite(input()))


l = list(input())
r = l.copy()
r.reverse()
s = ''.join(l) + ''.join(r)
print(s)


def solve():
	S = input()
	print(S + S[::-1])
solve()


nth = input()
print(nth + nth[::-1])


import math

def main():
	n = input()
	print(str(n) + ''.join(reversed(str(n))))
main()


n = int(input())
st1 = str(n)
st2 = ''.join(reversed(st1))
print(st1 + st2)


a = input()
print(a + a[::-1])


n = input()
st = n + n[::-1]
print(st)


def main():
	n = input()
	print(n, n[::-1], sep='')
main()


s = input()
s2 = ''
for i in s:
	s2 = i + s2
print(s + s2)


def reverse(string):
	string = string[::-1]
	return string
s = input()
s1 = reverse(s)
print(s + s1)


n = input()
res = n
if int(n) < 10:
	print(n * 2)
else:
	print(n + n[::-1])


n = input()
length = len(n)
a = [0] * length
j = 0
for i in range(length - 1, -1, -1):
	a[j] = n[i]
	j = j + 1
print(n + ''.join(a))


line = input()
text = line[::-1]
print(line + text)


x = input()
y = x[::-1]
print(x + y)


b = input()
print(b + b[::-1])


import sys
import os
str = input()
str2 = str[::-1]
str = str + str2
print(str)


num = input()
ll = len(num)
for x in range(ll - 1, -1, -1):
	num += num[x]
print(num)


n = input()
if int(n) < 10:
	print(n, end='')
	print(n)
elif int(n) == 10:
	print('1001')
elif int(n) == 11:
	print('1111')
else:
	print(n, end='')
	n = n[::-1]
	print(n)


s = input()
print(s, s[::-1], sep='')


q = input()
print(q + '' + q[::-1])


def even_palindrome(n):
	return n + n[::-1]
print(even_palindrome(input()))


x = input()
nx = x + x[::-1]
print(nx)


str1 = input()
rev_st = ''.join(reversed(str1))
str1 = str1 + rev_st
print(str1)


print((lambda x: x + x[::-1])(input()))


x = input()
print(x + ''.join(reversed(x)))


n = input()
t = ''.join(reversed(n))
print(n + t)


def solution(n):
	return ''.join(n + list(reversed(n)))
print(solution(list(input())))


s = input()
print(s, end='')
print(s[::-1])


s = str(input())
sr = s[::-1]
print(s + sr)


s = input()
print(s + ''.join(reversed(s)))


t = input()
s = t[::-1]
print(t + s)


s = input()
p = str(s)[::-1]
a = str(s) + p
print(a)


def revere(a):
	a = list(a)
	x = reversed(a)
	return ''.join(x)
n = input()
print(n + revere(n))


n = input()
c = n
i = 0
c1 = ''
c1 = c[::-1]
print(c + c1)


n = int(input())
ans = str(n) + str(n)[::-1]
print(ans)


num = input()
print(num + ''.join(reversed(list(num))))


n = str(input())
a = ''.join(reversed(n))
print(n + a)


n = list(input())
b = reversed(n)
print(*n, *b, end='', sep='')


string_input = input()
print(string_input + ''.join(reversed(string_input)))


s = str(input())
print(s, ''.join(reversed(s)), sep='')


num = input()
rnum = num[::-1]
print(num + rnum)


s = input()
rev = ''
for c in s:
	rev = c + rev
print(s + rev)


N = str(input())
print('%s%s' % (N, N[::-1]))


S = input()
print(S + S[::-1])


number = input()
reverse = ''
for i in range(len(number) - 1, -1, -1):
	reverse = reverse + number[i]
print(number + reverse)


x = input()
print(x + x[::-1])


n = int(input())
if n <= 9:
	print(n * 11)
else:
	print(str(n) + str(n)[::-1])


s = str(input())
print(s + s[::-1])


num = str(input())
ans = str(num) + str(num[::-1])
print(ans)


n = input()
s = n[::-1]
print(n + s)


from math import *
n = int(input())
s = str(n)
k = ''
for i in range(len(s) - 1, -1, -1):
	k = k + s[i]
k = s + k
print(k)


a = str(input())
i = len(a) - 1
while i >= 0:
	a += a[i]
	i -= 1
print(a)


n = input()
tmp = n
print(n + n[::-1])


h = input()
print(h + h[::-1])


n = input()
n_list = list(n)
reversed_n_list = n_list.copy()
reversed_n_list.reverse()
n_list += reversed_n_list
print(''.join(n_list))


n = input()

def evenlength(n):
	res = n
	for j in range(len(n) - 1, -1, -1):
		res += n[j]
	return res
z = evenlength(n)
print(z)


n = list(input())
ans = n + n[::-1]
print(''.join(ans))


s = input()
ans = s
ans += s[::-1]
print(ans)


n = input()
n = list(n)
a = n[::-1]
n.append(''.join(a))
print(*n, sep='')


a = input()
b = ''
for i in range(len(a)):
	b += a[-(i + 1)]
print(a + b)


import sys

def ints_input():
	return [int(i) for i in sys.stdin.readline().strip('\n').split(' ')]

def print_list(arr):
	sys.stdout.writelines((str(x) + ' ' for x in arr))
	sys.stdout.write('\n')

def fast_input(type=str):
	return type(sys.stdin.readline().strip('\n'))
n = fast_input(int)
n = list(str(n))
rev_n = n[-1:-len(n) - 1:-1]
print(''.join(n + rev_n))


N = input()
print(N + ''.join(list(N)[::-1]))


a = input()
print(a + ''.join(reversed(a)))


k = input()
print(k + k[::-1])


s = list(input())
s2 = list(reversed(s))
for i in s:
	print(i, end='')
for i in s2:
	print(i, end='')


from math import ceil, sqrt, floor
import sys
n = input()
print(n, n[::-1], sep='')


import sys
s = sys.stdin.readline().strip()
print(s + s[::-1])


n = input()
print(n, n[::-1], sep='')


s = list(input())
r = [''] * len(s)
for i in range(len(s)):
	r[len(s) - 1 - i] = s[i]
res = s + r
print(''.join(map(str, res)))


n = input()
for i in n:
	print(i, end='')
for i in range(len(n) - 1, -1, -1):
	print(n[i], end='')


n = input()
n_back = ''
for index in range(len(n) - 1, -1, -1):
	n_back += n[index]
print(n + n_back)


from sys import stdin, stdout

def istr():
	return input()

def inum():
	return int(stdin.readline())

def imul():
	return map(int, stdin.readline().split())

def ilst():
	return list(map(int, stdin.readline().split()))

def splt():
	return list(stdin.readline().strip())

def emat(row):
	return [ilst() for i in range(row)]
max_itr = 100
from itertools import combinations
import math
n = inum()
a = str(n)
b = a[::-1]
print(a + b)


num = input()
i = len(num) - 1
r = ''
while i >= 0:
	r += num[i]
	i -= 1
print(num + r)


x = input()
z = x[::-1]
t = x + z
print(t)


import sys
input = sys.stdin.readline
read_tuple = lambda _type: map(_type, input().split(' '))

def solve():
	n = str(int(input()))
	print(n + n[::-1])
solve()


n = str(input())
r = list(n)
r.reverse()
r = ''.join(r)
print(n + r)


n = input()
n_Array = [int(i) for i in str(n)]
rn_Array = [int(e) for e in reversed(n_Array)]
valx = ''.join((str(x) for x in n_Array))
valy = ''.join((str(y) for y in rn_Array))
palValue = valx + valy
print(palValue)


f = input()
print(f + f[::-1])


z = list(input())
x = z.copy()
x.reverse()
z = z + x
print(''.join(z))


n = input()
pal = []
for i in range(len(n)):
	pal.append(n[i])
for i in range(len(n) - 1, -1, -1):
	pal.append(n[i])
print(''.join(pal))


a = str(input())
b = ''
b += a
b += a[::-1]
print(b)


s = input()
print(s, end='')
for i in range(len(s) - 1, -1, -1):
	print(s[i], end='')


pos = input()
sep = '1'
ans = pos[::-1]
pos += ans
print(pos)


N = input()
M = ''
for i in range(len(N)):
	M += N[i]
for i in range(len(N)):
	M += N[len(N) - i - 1]
print(M)


n = input().rstrip()
print(n + n[::-1])


s = input()
print(''.join([s, s[::-1]]))


t = input()
print(t + ''.join(reversed(t)))


a = input()
b = a + a[::-1]
print(b)


n = input()
w = n
n = n[::-1]
w = w + n
print(w)


import sys
sin = sys.stdin.readline().strip()
out = ''
for i in range(0, len(sin), 1):
	out += str(int(sin[i]))
for i in range(len(sin) - 1, -1, -1):
	out += str(int(sin[i]))
sys.stdout.write(out)


s = list(input())
s += reversed(s)
print(*[x for x in s], sep='')


n = input()
k = n[-1:-len(n) - 1:-1]
n = n + k
print(n)


n = input()
b = n[::-1]
print(n + b)


x = input()
print(x, end='')
print(x[::-1])


print((lambda s: s + s[::-1])(input()))


n = input()
x = n[::-1]
print(n + x)


import re
from sys import stderr
from typing import Union, Generator, List, Tuple
import string
INF = 2e+18 + 3
EPS = 1e-10

def main():
	s = input()
	print(s + s[::-1])
main()


n = str(input())
l = n[::-1]
print(n + l)


s = input()
r = ''.join(reversed(list(s)))
print(s + r)


import math

def main():
	ans = input()
	ans += ans[::-1]
	print(ans)
main()


n = input()
ans = n + n[::-1]
print(ans)


def getLine():
	return list(map(int, input().split()))

def main():
	n = input()
	print(n, n[::-1], sep='')
main()


n = input()
s = n
for x in range(len(n), 0, -1):
	s += s[x - 1:x]
print(s)


n = input()
ans = n
for i in range(len(n) - 1, -1, -1):
	ans = ans + n[i]
print(ans)


n = input()
s = n
for i in range(len(n)):
	s = s + n[len(n) - 1 - i]
print(s)


n = input()
for c in reversed(n):
	n += c
print(n)


x = input()
c = x + x[::-1]
print(c)


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt
from bisect import bisect_right, bisect_left
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factorial(n):
	if n == 0:
		return 1
	return n * factorial(n - 1)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return len(set(factors))

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def printp(p):
	for i in p:
		print(i)
MOD = 10 ** 9 + 7
T = 1
for _ in range(T):
	s = str(stdin.readline().strip('\n'))
	print(s + s[::-1])


n = list(input())
m = n.copy()
n.reverse()
m.extend(n)
print(''.join(m))


n = input()
output = ''
output += n
n = list(n)
for i in range(len(n) - 1, -1, -1):
	output += n[i]
print(output)


n = input()
n2 = n[::-1]
print(n + n2)


a = input()
print(a, end='')
print(a[::-1])


p = input()
print(p + p[::-1])


i = input()
i += ''.join(reversed(i))
print(i)


a = input()
print(a + ''.join(list(reversed(a))))


def find_nth_palindrome():
	n = input()
	return n + n[::-1]
print(find_nth_palindrome())


a = input()
b = list(a[:])
b.reverse()
print(a, end='')
for i in range(len(b)):
	print(b[i], end='')


n = [str(x) for x in input().split()][0]
print(n + n[::-1])


a = input()
print(a + a[len(a) - 1::-1])


n = input()
k = ''
for i in range(len(n)):
	k += n[len(n) - i - 1]
print(n + k)


number = str(input())
res = number + number[::-1]
print(res)


n = list(input())
p = list(n)
n.reverse()
print(*p + n, sep='')


from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
from math import ceil, floor, log, sqrt, factorial, pow, pi

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p1
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph():
	d = {}
	(v, e) = mi()
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(l, n):
	d = {}
	for i in range(1, n + 1):
		if i not in d.keys():
			d[i] = l[i]
		else:
			d[i].append(l[i])
	return d
s = si()
s1 = s[::-1]
print(s + s1)


import sys

def main():
	n = input()
	print(n + n[::-1])
main()


import sys
s = input()
ans = ''
for i in range(len(s)):
	ans += s[i]
print(ans + ans[::-1])


import math, sys, re
(rs, ri, rai) = (input, lambda : int(input()), lambda : list(map(int, input().split())))
s = rs()
print(s, end='')
for i in reversed(s):
	print(i, end='')


s = input().rstrip()
print(s + s[::-1])


n = input()
l = n[-1::-1]
print(n + l)


n = input()
nrev = n[::-1]
print(n + nrev)


r = input()
r = r + r[::-1]
print(r)


s1 = input()
s2 = s1[::-1]
s3 = s1 + s2
print(s3)


w = input()
ans = w + w[::-1]
print(ans)


n = input().strip('\n')
print(n + n[::-1])


s = input()
z = s[::-1]
m = s + z
print(m)


number = str(input())
pal = ''
for i in range(len(number)):
	pal += number[i]
p = len(number) - 1
while p >= 0:
	pal += number[p]
	p -= 1
print(pal)


n = input()
s = n + ''.join(reversed(n))
print(s)


import sys
from collections import deque

def main(n):
	q = deque()
	for i in range(len(n) - 1, -1, -1):
		q.appendleft(n[i])
		q.append(n[i])
	print(''.join((d for d in q)))
mat = []
for (e, line) in enumerate(sys.stdin.readlines()):
	if e == 0:
		n = line.strip()
main(n)


n = input()
print(str(n) + str(n)[::-1])


a = input()
s = []
for i in a:
	s.append(i)
s.reverse()
s = ''.join(s)
print(a + s)


z = list(input())
print(''.join(z) + ''.join(reversed(z)))


n = input()
p = n[::-1]
print(n + p)


c = input()
print(c, end='')
c = list(c)
c.reverse()
print(''.join(c))


import statistics
import math
import datetime
from collections import Counter
import itertools
n = input()
print(n + n[::-1])


a = input()
print(a, a[::-1], sep='')


s = list(input())
k = s + []
s.reverse()
print(''.join(k + s))


a = input()
b = ''
for i in a:
	b = i + b
print(a + b)


n = list(input())
a = [n[-i - 1] for i in range(len(n))]
c = n + a
print(''.join(c))


n = input()
l = len(n)
a = ''
a += n
a += n[::-1]
print(a)


n = int(input())
a = str(n)
print(a + a[::-1])


t = input()
print(t + t[::-1])


import sys
n = str(input())
sys.stdout.write(n)
print(n[::-1])


s = input()
pass
pass
pass
pass
pass
pass
pass
print(s + s[::-1])


import sys
import bisect
from collections import deque
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
n = ri()
print(n + n[::-1])


s = str(input())
x = s[::-1]
s += x
print(s)


s = str(input())
print(s, end='')
for _ in range(len(s) - 1, -1, -1):
	print(s[_], end='')


def palin(num):
	f_no = num + num[::-1]
	print(f_no)
num = input()
palin(num)


ara = input()
print(ara + ara[::-1])


n = int(input())
if n < 10:
	print(2 * str(n))
else:
	s = ''
	w = str(n)
	for i in w:
		s += i
	print(s + s[::-1])


n = input()
m = ''.join(reversed(n))
print(n, end='')
print(m)


integer_input = input()
print(integer_input + ''.join(reversed(integer_input)))


n1 = input()
n2 = ''
for f in range(len(n1) - 1, -1, -1):
	n2 += n1[f]
print(n1 + n2)


n = input()
a = []
for i in n:
	a.append(i)
B = list(reversed(a))
s = ''
for j in B:
	n = n + j
print(n)


n = str(input())
out = n
for i in range(len(n) - 1, -1, -1):
	out = out + n[i]
print(out)


input = input()
print(input + input[::-1])


import random
import sys
import os
s = input()
print(s + s[::-1])


y = input()
print(y + y[::-1])


x = input()
y = x + ''.join(reversed(x))
print(y)


n = input()
r = n[::-1]
print(n + r)


asd = input()
print(asd + asd[::-1])


def e_palindrome(n):
	return n + n[::-1]
n = input()
print(e_palindrome(n))


n = input()
b = n[::-1]
c = n + b
print(c)


def fun(n):
	return n[::-1]
n = input()
n += fun(n)
print(n)


n = int(input())
s = str(n)
a = s
b = s[-1::-1]
print(a + b)


from sys import stdin
from collections import defaultdict
input = lambda : stdin.readline().strip()
n = int(input())
s = str(n)
print(s + s[::-1])


n = int(input())
lis = [str(i) + str(i) for i in range(0, 10)]
if n < 10:
	print(lis[n])
else:
	pali = str(n) + str(n)[::-1]
	print(pali)


s = str(input())
print(s, end='')
for i in range(len(s), 1, -1):
	print(s[i - 1], end='')
print(s[0])


def main():
	num_palindrome = input()
	print(num_palindrome + num_palindrome[::-1])
main()


x = input()
ar = []
s = ''
g = []
for i in x:
	ar.append(i)
	g.append(i)
ar.reverse()
d = g + ar
p = s.join(d)
print(p)


while 1:
	try:
		s = str(input())
		s1 = s
		for i in range(1, len(s) + 1):
			s1 += s[-i]
		print(s1)
	except:
		break


num = input()
mirr = num[::-1]
pal = num + mirr
print(pal)


n = list(str(input()))
y = n.copy()
n.reverse()
print(*y + n, sep='')


ans = input()
print(ans, end='')
for ch in list(reversed(ans)):
	print(ch, end='')


a = input()
s = ''
for x in a:
	s = x + s
print(a + s)


n = input()
nr = n[::-1]
print(n + nr)


b = input('')
s = b[::-1]
print(b + s)


a = str(input())
print(a, end='')
print(a[::-1])


n = input()
rn = n[::-1]
print(n + rn)


n = input()
s1 = list(n)
s1.reverse()
n1 = ''.join(s1)
print(n + n1)


t = input()
print(t, end='')
for c in t[::-1]:
	print(c, end='')
print('')


n = input()
m = str()
for i in range(len(n)):
	m += n[-i - 1]
print(n + m)


n = input()

def reverse(s):
	return s[::-1]
print(n + reverse(n))


n = int(input())
l = list(str(n))
x = []
for i in range(1, len(l) + 1):
	x.append(l[len(l) - i])
print(str(n) + ''.join((str(i) for i in x)))


n = [x for x in input()]
x = len(n)
for j in range(x - 1, -1, -1):
	n.append(n[j])
print(''.join(n))


def EvenPalindrome(n):
	return str(n) + str(n)[::-1]
n = int(input())
print(EvenPalindrome(n))


n = str(input().strip())
print(n + ''.join(list(n)[::-1]))


a = input()
a = list(a)
s = a.copy()
a.reverse()
print(''.join(s + a))


inp = input()
print(inp + inp[::-1])


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
import math
from fractions import Fraction
n = si()
a = n[::-1]
ans = ''
ans += n + a
print(ans)


s = list(input())
f = ''.join(s)
s.reverse()
print(f + ''.join(s))


from decimal import *
from sys import *
from math import *
s = input().strip()
print(s + s[-1:-len(s) - 1:-1])


i = 0
n = input('')
f = len(n) - 1
while len(n) > i:
	print(n[i], end='')
	i += 1
while f >= 0:
	print(n[f], end='')
	f -= 1


b = input()
print(b + ''.join(reversed(b)))


n = input()
a = list(n)
b = a[::-1]
m = ''.join(b)
print(n, end='')
print(m)


n = input()
c = len(n) - 1
s = n
while c >= 0:
	s += n[c]
	c -= 1
print(s)


from collections import deque as de
import math
from collections import Counter as cnt
from functools import reduce
from typing import MutableMapping
from itertools import groupby as gb
from fractions import Fraction as fr

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0
arrStack = My_stack()

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic

def Log2(x):
	return math.log10(x) / math.log10(2)

def isPowerOfTwo(n):
	return math.ceil(Log2(n)) == math.floor(Log2(n))

def ceildiv(x, y):
	return (x + y - 1) // y

def di():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))
n = input()
print(n + n[::-1])


t = list(input())
a = t[::-1]
for i in a:
	t.append(i)
print(''.join((str(x) for x in t)))


b = input()
result = ''
for c in b:
	result = c + result
print(b + result)


n = input()
x = list(n)
x.reverse()
x = ''.join(x)
print(n + x)


n = input()
firstArray = [int(i) for i in str(n)]
secondArray = [int(e) for e in reversed(firstArray)]
a = ''.join((str(x) for x in firstArray))
b = ''.join((str(y) for y in secondArray))
Value = a + b
print(Value)


s = input()
res = s
for i in range(len(s) - 1, -1, -1):
	res += s[i]
print(res)


import time
n = input()
start = time.time()
for i in range(len(n)):
	print(n[i], end='')
for i in range(len(n)):
	print(n[len(n) - 1 - i], end='')
print()
finish = time.time()


x = input()
y = ''
r = len(x) - 1
while r >= 0:
	y += x[r]
	r -= 1
x += y
print(x)


import sys
import math

def main():
	s = sys.stdin.readline().strip()
	s = s + s[::-1]
	print(s)
main()


__author__ = 'artyom'

def main():
	s = read(0)
	return s + s[::-1]

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
write(main())


import copy
a = list(input())
b = copy.copy(a)
b.reverse()
c = a + b
print(''.join(c))


n = input()
l = []
for i in range(len(n)):
	l.append(n[i])
l2 = l[-1::-1]
l3 = l + l2
c = ''.join(l3)
print(c)


x = input()
print(x + ''.join(list(reversed(x))))


num = input()
if int(num) < 10:
	print(int(num) * 11)
else:
	temp = ''
	for i in range(len(num) - 1, -1, -1):
		temp = temp + num[i]
	print(num + temp)


n = input()
l = 2 * len(n)
print(n + n[l - 1::-1])


def main(n):
	n2 = str(n)[::-1]
	return str(n) + str(n2)
n = input()
print(main(n))


hat = input()
hat += hat[::-1]
print(hat)


digits = list(input())
n = len(digits)
for i in range(0, n):
	print(digits[i], end='')
for i in range(n - 1, -1, -1):
	print(digits[i], end='')


n = input()
a = n[::-1]
print(n + a)


import math
n = input()
print(n + n[::-1])


t = input()
a = len(t)
print(t, end='')
for i in range(a - 1, -1, -1):
	print(t[i], end='')


str = input()
print(str + str[::-1])


def palindrome(n):
	n += n[::-1]
	return n
num = input()
print(palindrome(num))


x = input()
s = x + ''.join(reversed(x))
print(s)


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = input()
print(n + n[::-1])


a = input()
s = a
for i in range(len(a) - 1, -1, -1):
	s += a[i]
print(s)


n = input()
n = n + ''.join(reversed(n))
print(n)


s = input().strip()
print(s + s[::-1])


def a():
	(_, d) = (int(x) for x in input().split())
	curr_win_streak = 0
	max_win_streak = 0
	for _ in range(d):
		if '0' in input():
			curr_win_streak += 1
		else:
			curr_win_streak = 0
		max_win_streak = max(max_win_streak, curr_win_streak)
	print(max_win_streak)

def b():
	x = input()
	print(x + x[::-1])
b()


num = input()
palindrome = num + num[::-1]
print(palindrome)


s = input()
s1 = list(s)
s1.reverse()
print(s + ''.join(s1))


S = input()
S1 = ''
for i in range(-1, -len(S) - 1, -1):
	S1 = S1 + S[i]
print(S + S1)


n = input()
r1 = n[::-1]
print(n + r1)


stra = str(input())
print(stra, end='')
l = len(stra)
for i in range(0, l):
	print(stra[l - i - 1], end='')
print()


n = input()
for i in range(len(n), 0, -1):
	n += n[i - 1]
print(n)


n = list(input())
temp = n.copy()
temp.reverse()
print(''.join(n) + ''.join(temp))


inp = input()
print(inp + ''.join(inp[::-1]))


v = input()
print(v + v[::-1])


n = input()
h = 'Dsadasdasdasddasdasdasdasdasdasdasdasd'
print(n + n[::-1])


israil = input()
print(israil + israil[::-1])


response = input()
palindrome = response + response[::-1]
print(palindrome)


a = list(input())
print(''.join(a + a[::-1]))


c = list(input())
d = c.copy()
c.reverse()
print(''.join(d + c))


l1 = list(input())
l2 = l1.copy()
l2.reverse()
print(''.join(l1) + ''.join(l2))


import math

def get_primes(prime_supr):
	is_prime = [0] * 2 + [1] * prime_supr
	for i in range(2, int(math.sqrt(prime_supr)) + 1):
		if is_prime[i]:
			for j in range(i * i, prime_supr + 1, i):
				is_prime[j] = 0
	return is_prime
get_int = lambda : map(int, input().split())
a = input()
print(a, end='')
print(a[::-1])


n = input()
l1 = []
for i in n:
	l1.append(i)
l2 = l1[::-1]
l3 = l1 + l2
for i in l3:
	print(i, end='')


n = list(input())
n = n + list(reversed(n))
print(*n, sep='')


n = input()
reverseNum = ''.join(reversed(n))
n = n + reverseNum
print(n)


a = input()
print(a, ''.join(reversed(a)), sep='')


a = list(map(int, input()))
wr = ''
for i in range(0, len(a)):
	wr = wr + str(a[i])
for i in range(len(a) - 1, -1, -1):
	wr = wr + str(a[i])
print(wr)


def reverse_slicing(s):
	return s[::-1]
n = input()
x = n
temp = reverse_slicing(x)
print(n + temp)


x = int(input())
print(str(x) + str(x)[::-1])


b = input()
a = list(b)
for i in range(1, len(a) + 1):
	b += a[-i]
print(str(b))


str1 = input()
z = len(str1)
str2 = str1
for i in range(len(str1)):
	str2 = str2 + str1[-(i + 1)]
print(str2)


n = int(input())
ch = str(n)
ch1 = ch[::-1]
print(ch + ch1)


n = input().strip()
size = 2 * len(n)
res = ['0'] * size
offset = 0
for d in n:
	res[offset] = res[size - offset - 1] = d
	offset += 1
print(''.join(res))


n = str(input())
y = n[::-1]
x = n + y
print(x)


def main():
	s = input()
	d = s[::-1]
	print(s + d)
main()


n = str(input())
print(n, end='')
print(''.join(reversed(n)))


n = input()
j = len(n) - 1
while j >= 0:
	n += n[j]
	j = j - 1
print(n)


def ispal(x):
	for i in range(len(x) // 2):
		if x[i] != x[len(x) - i - 1]:
			return 0
	return 1
k = 1
n = int(input())
n = str(n)
print(n + n[::-1])


n = input()
N = list(n)
N.reverse()
ans = list(n) + N
str1 = ''
for i in ans:
	str1 += i
print(str1)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def Reverse(lst):
	return [ele for ele in reversed(lst)]
n = insr()
if len(n) == 1:
	print(''.join(n + n))
else:
	s = Reverse(n)
	print(''.join(n), end='')
	print(''.join(s))


a = str(input())
print(a + a[-1::-1])


n = input()
f = ''
t = -1
for i in range(len(n)):
	f += n[t]
	t -= 1
print(n + f)


s = input()
print(s, end='')
longueur = len(s)
for iLongueur in range(longueur):
	print(s[longueur - iLongueur - 1], end='')


n = input()
n1 = n[::-1]
print(n + n1)


t = int(input())
print(str(t) + str(t)[::-1])


t = int(input())
t1 = str(t)
t2 = t1[::-1]
t1 = t1 + t2
print(t1)


def solve():
	n = input()
	return f'{n}{n[::-1]}'
print(solve())


s = input()
print(s, end='')
for c in reversed(s):
	print(c, end='')
print()


mytxt = input()
print(mytxt + mytxt[::-1])


from sys import *
input = lambda : stdin.readline()
int_arr = lambda : list(map(int, stdin.readline().strip().split()))
str_arr = lambda : list(map(str, stdin.readline().split()))
get_str = lambda : map(str, stdin.readline().strip().split())
get_int = lambda : map(int, stdin.readline().strip().split())
get_float = lambda : map(float, stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
s = str(input())[:-1]
print(s + s[::-1])


n = input()
n1 = ''
i = len(n) - 1
while i >= 0:
	n1 += n[i]
	i -= 1
print(n + n1)


s = input()
n = len(s)
for i in range(0, n):
	print(s[i], end='')
for i in range(n - 1, -1, -1):
	print(s[i], end='')


n = input()
out = n + n[::-1]
print(out)


s = input()
w = s[::-1]
print(s + w)


input_str = input()
print(input_str, end='')
print(input_str[::-1], end='')


n = input()
A = n
print(n, end='')
print(A[::-1])


n = input()
r = ''
for i in range(len(n) - 1, -1, -1):
	r = r + n[i]
print(n + r)


n = input()
ans = n
i = 1
try:
	while 1:
		ans += n[-i]
		i += 1
except:
	print(ans)


n = int(input())
n = str(n)
answer = list(n)
for character in reversed(answer):
	answer.append(character)
print(''.join(answer))


import math
import os
import random
import re
import sys
n = input()
s = n
s = n + n[::-1]
print(s)


num = input()
print(num + num[::-1])


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	s = S()
	return s + s[::-1]
print(main())


s = input()
t = list(s)
t.reverse()
print(s, end='')
for i in t:
	print(i, end='')
print()


n = input().strip()
s = n + n[::-1]
print(s)


n = input()
rev_n = ''.join(reversed(n))
print(n, rev_n, sep='')


m = input()
r = ''
for i in range(len(m) - 1, -1, -1):
	r = r + m[i]
print(m + r)


n = str(input())
l = len(n)
print(n, end='')
for i in range(l):
	print(n[l - i - 1], end='')


n = input()
h = reversed(n)
print(n, end='')
for x in n[::-1]:
	print(x, end='')


import sys
import os

def get_int():
	return map(int, input().split())

def get_array():
	return list(map(int, input().split()))

def str_replacer(old_str, new_str, index):
	if index in range(len(old_str)):
		return old_str[:index] + new_str + old_str[index + 1:]
	else:
		return old_str
if os.environ.get('DEBUGSTER_PYTHON'):
	sys.stdin = open('in.txt', 'r')
	sys.stdout = open('out.txt', 'w')
s = input()
print(s + s[-1::-1])


num = input()

def get_poly_by_number(num):
	str_num = str(num)
	return ''.join([str_num, str_num[::-1]])
print(get_poly_by_number(num))


string = input()
toPrint = [string, string[::-1]]
print(''.join(toPrint))


def evenlength(n):
	res = n
	res += n[::-1]
	return res
n = input()
print(evenlength(n))


n = input()
n_Array = [int(i) for i in str(n)]
rn_Array = [int(e) for e in reversed(n_Array)]
val1 = ''.join((str(x) for x in n_Array))
val2 = ''.join((str(y) for y in rn_Array))
palValue = val1 + val2
print(palValue)


t = input()
print(t, t[::-1], sep='')


s = input()
t = ''
for c in reversed(s):
	t += c
print(s + t)


n = input()
rev = n[::-1]
print(n + rev)


n = list(str(input()))
p = []
l = []
for i in range(len(n)):
	p.append(n[i])
	l.append(n[len(n) - 1 - i])
s = ''.join(l)
t = ''.join(p)
print(t + s)


str = list(input())
for i in str[::-1]:
	str.append(i)
for i in str:
	print(i, end='')


ip = input()
print(ip + ip[::-1])


n = int(input())
s = str(n)
d = s
for i in range(len(s) - 1, -1, -1):
	d = d + s[i]
print(d)


n = input()
for i in reversed(range(len(n))):
	n += n[i]
print(n)


is_debug = False
s = input()
print(f'{s}{s[::-1]}')


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

def read_ints():
	return [int(x) for x in stdin.readline().split()]

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
inp = read_str()
print(inp + inp[::-1])


s = input()
r = s
a = int(len(s))
if len(s) < 2:
	print(s + s)
else:
	for i in range(len(s)):
		r = r + s[len(s) - i - 1]
	print(r)


output = input()
output = output + output[::-1]
print(output)


n = input()
c = n[::-1]
print(n + c)


import sys
input = sys.stdin.readline
s = input().strip()
sys.stdout.write(s + s[::-1])


s = input()
s1 = s[::-1]
print(s + s1)


string = input()
print(string + ''.join(reversed(string)))


n = input()
reverse = n[::-1]
result = n + reverse
print(result)


a1 = input()
a1 = a1 + a1[::-1]
print(a1, end='')


def f():
	x = input()
	print(x, end='')
	print(x[::-1])
f()


from collections import deque
from collections import Counter
from itertools import permutations
import heapq

def counterExample():
	arr = [1, 3, 4, 1, 2, 1, 1, 3, 4, 3, 5, 1, 2, 5, 3, 4, 5]
	counter = Counter(arr)
	top_three = counter.most_common(3)
	print(top_three)
q = deque()

def main():
	n = input()
	print(n + n[::-1])
main()


def single_integer():
	return int(input())

def multi_integer():
	return map(int, input().split())

def string():
	return input()

def multi_string():
	return input().split()
s = string()
print(s + s[::-1])


s = input()
pal = s + s[::-1]
print(pal)


n = input()
result = n + n[::-1]
print(result)


def solve(n):
	return n + n[::-1]

def main():
	n = input()
	print(solve(n))
main()


i = input()
i = i + i[-1:-len(i) - 1:-1]
print(i)


a = input()
A = []
for i in range(len(a)):
	A.append(a[i])
counter = len(a) - 1
while counter >= 0:
	A.append(a[counter])
	counter = counter - 1
s = ''
for i in A:
	s = s + i
print(s)


x = input()
a = x[::-1]
print(x + a)


s = input()
ss = s[::-1]
res = s + ss
print(res)


n = input()
n1 = ''
for i in range(len(n)):
	n1 += n[len(n) - i - 1]
print(n, n1, sep='')


inp = input()
print(inp, end='')
print(inp[::-1])


x = input()
s = x[::-1]
print(x + s)


__author__ = 'aste'

def main():
	n = input()
	print(n + n[::-1])
main()


class Solution:

	def solve(n: str) -> str:
		return f'{n}{n[::-1]}'
n = input()
result = Solution.solve(n)
print(result)


from sys import stdin
n = stdin.readline().rstrip()
print(n + n[::-1])


import math
n = int(input())
s = str(n)
print(s + s[::-1])


strr = input()
strrrev = strr[::-1]
print(strr + strrrev)


s = input()
s = s + s[::-1]
if s == s[::-1]:
	print(s)


X = input()
print(X + ''.join(reversed(X)))


from sys import stdin, stdout
s = stdin.readline().rstrip()
stdout.write(s + s[::-1])


p = input()
print(p, p[::-1], sep='')


strin = input()
print(strin + strin[::-1])


from math import gcd
from functools import reduce
from itertools import accumulate
from typing import List
import bisect
import random
from itertools import permutations, combinations
from collections import Counter

def listAll(func, nums: list) -> bool:
	for x in nums:
		if not func(x):
			return False
	return True

def transformStrings(func) -> list:
	return list(map(func, readStrings()))

def getOrNone(iterable, index):
	if 0 <= index < len(iterable):
		return iterable[index]
	return None

def getOrDefault(iterable, index, default):
	if 0 <= index < len(iterable):
		return iterable[index]
	return default

def digitSum(num: int) -> int:
	numString = str(num)
	value = 0
	for x in numString:
		value += int(x)
	return value

def runningReduce(func, nums: list) -> list:
	values = nums.copy()
	for x in range(1, len(nums)):
		values[x] = func(values[x - 1], nums[x])
	return values

def lcm(a, b) -> int:
	return abs(a * b) // gcd(a, b)

def printList(nums: list, end='\n'):
	nums = list(map(lambda x: str(x), nums))
	print(' '.join(nums), end=end)

def readStrings() -> List[str]:
	return input().split(' ')

def readInt() -> int:
	return int(input())

def readInts() -> List[int]:
	return list(map(lambda x: int(x), readStrings()))

def readOtherNumericTypes(func) -> list:
	return list(map(func, readStrings()))

def isEven(num: int) -> bool:
	return num % 2 == 0

def isPositive(num: int) -> bool:
	return num > 0

def isPositiveOrZero(num: int) -> bool:
	return isPositive(num) or num == 0

def digits(num: int) -> int:
	return len(str(num))

def firstDigit(num: int) -> int:
	return int(str(num)[0])
num = input()
print(num + num[::-1])


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
s = input()
print(s + s[::-1])


def rev(a):
	b = []
	for i in a:
		b.append(i)
	c = reversed(b)
	d = ''.join(c)
	print(a + d)
a = input()
if len(a) == 1:
	print(a * 2)
else:
	rev(a)