A string S of an odd length is said to be a strong palindrome if and only if all of the following conditions are satisfied:
 - S is a palindrome.
 - Let N be the length of S. The string formed by the 1-st through ((N-1)/2)-th characters of S is a palindrome.
 - The string consisting of the (N+3)/2-st through N-th characters of S is a palindrome.
Determine whether S is a strong palindrome.

-----Constraints-----
 - S consists of lowercase English letters.
 - The length of S is an odd number between 3 and 99 (inclusive).

-----Input-----
Input is given from Standard Input in the following format:
S

-----Output-----
If S is a strong palindrome, print Yes;
otherwise, print No.

-----Sample Input-----
akasaka

-----Sample Output-----
Yes

 - S is akasaka.
 - The string formed by the 1-st through the 3-rd characters is aka.
 - The string formed by the 5-th through the 7-th characters is aka.
All of these are palindromes, so S is a strong palindrome.

Difficulty: EASY

Solutions:
S = input()
N = len(S)
Sf = S[0:(N - 1) // 2]
NSf = len(Sf)
Sb = S[(N + 3) // 2 - 1:N + 1]
NSb = len(Sb)
ans = 0
for i in range(N // 2):
	if S[i:i + 1] != S[N - 1 - i:N - i]:
		ans = 1
for i in range(NSf // 2):
	if Sf[i:i + 1] != Sf[NSf - 1 - i:NSf - i]:
		ans = 1
for i in range(NSb // 2):
	if Sb[i:i + 1] != Sb[NSb - 1 - i:NSb - i]:
		ans = 1
print('Yes') if ans == 0 else print('No')


s = input()
n = len(s)
s1 = s[0:(n - 1) // 2]
s2 = s[(n + 1) // 2:n]
s_reverse = s[::-1]
s1_reverse = s1[::-1]
s2_reverse = s2[::-1]
if s == s_reverse and s1 == s1_reverse and (s2 == s2_reverse):
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
print('Yes' if S == S[::-1] and S[:N // 2] == S[-N // 2 + 1:] else 'No')


S = str(input())
N = len(S)
sList = [str(s) for s in S]
isPalindrome = 1
str1 = ''
str2 = ''
str3 = ''
str4 = ''
for i in range(N):
	if sList[i] != sList[N - 1 - i]:
		isPalindrome = 0
if isPalindrome == 1:
	for i in range(int((N - 1) / 2)):
		str1 += sList[i]
		str2 += sList[int((N - 1) / 2 - 1 - i)]
		str3 += sList[int((N + 3) / 2 - 1 + i)]
		str4 += sList[N - 1 - i]
		if str1 != str2:
			isPalindrome = 0
		if str3 != str4:
			isPalindrome = 0
if isPalindrome == 0:
	print('No')
else:
	print('Yes')


a = str(input())
b = len(a)
c = (b - 1) // 2
d = (b + 3) // 2
if a[:c] == a[d - 1:]:
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
a = S[0:(N - 1) // 2]
b = S[N - (N - 1) // 2:]
if a == b:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
if not s[0:(n - 1) // 2] == s[(n + 1) // 2:n]:
	print('No')
elif s == s[::-1]:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
if s[:(n - 1) // 2] == s[:(n - 1) // 2][::-1] and s == s[::-1]:
	print('Yes')
else:
	print('No')


S = input().strip()
s = S[:len(S) // 2]
print('Yes' if S == S[::-1] and s == s[::-1] else 'No')


s = input()
n = len(s) // 2
print('YNeos'[s[:n] != s[n + 1:]::2])


s = input()
N = len(s)
a = s[:N // 2]
if N % 2 == 0:
	b = s[N // 2:]
else:
	b = s[N // 2 + 1:]
if a == a[::-1] and b == b[::-1] and (a == b):
	print('Yes')
	return
print('No')


A = input()
B = A[0:len(A) // 2]
if A != A[::-1]:
	print('No')
elif B != B[::-1]:
	print('No')
else:
	print('Yes')


s = input()
mid = len(s) // 2
if s == s[::-1] and s[:mid] == s[mid + 1:]:
	print('Yes')
else:
	print('No')


a = input()
an = len(a)
dan = an // 2
if a[:dan] == a[dan + 1:]:
	print('Yes')
else:
	print('No')


S = input()
l = len(S) // 2
former = S[:l]
latter = S[l + 1:]
print('Yes' if S == S[::-1] and former == former[::-1] and (latter == latter[::-1]) else 'No')


S = input()
if S[:int((len(S) - 1) / 2)] == S[int((len(S) + 3) / 2) - 1:]:
	print('Yes')
else:
	print('No')


def resolve():
	s = input()
	if s == s[::-1]:
		s_1 = s[:len(s) // 2]
		s_2 = s[(len(s) + 1) // 2:]
		if s_1 == s_1[::-1] and s_2 == s_2[::-1]:
			print('Yes')
		else:
			print('No')
	else:
		print('No')
resolve()


S = input()
halfS = S[:len(S) // 2]
ans = 'No'
if S == S[::-1]:
	if halfS == halfS[::-1]:
		ans = 'Yes'
print(ans)


s = list(input())
if s[0:(len(s) - 1) // 2] == s[(len(s) + 3) // 2 - 1:len(s)]:
	print('Yes')
else:
	print('No')


s = input()
n = len(s) // 2
if s[:n] == s[-n:]:
	print('Yes')
else:
	print('No')


S = input()
if S[0:len(S) // 2] == S[len(S) // 2 + 1:len(S)]:
	print('Yes')
else:
	print('No')


S = str(input())
x = int((len(S) - 1) / 2)
if S[:x] == S[-x:]:
	print('Yes')
else:
	print('No')


S = input()
size = len(S)

def palin(S, size):
	for i in range(size // 2):
		if S[i] != S[-1 - i]:
			return False
	return True
if palin(S, size) == True:
	L = S[:size // 2]
	R = S[size // 2 + 2:]
	if palin(L, size // 2) & palin(L, size // 2):
		print('Yes')
	else:
		print('No')
else:
	print('No')


s = input()
h = len(s) // 2
print(' YNeos'[s[:h] == s[h - 1::-1] == s[-h:]::2])


s = input()
s_len = len(s)
if s[:int((s_len - 1) / 2)] == s[int((s_len + 3) / 2) - 1:]:
	print('Yes')
else:
	print('No')


s = input()
ans = 'No'
n = len(s)
if s == s[::-1]:
	tmp = s[0:(n - 1) // 2]
	if tmp == tmp[::-1]:
		tmp = s[(n + 3) // 2 - 1:]
		if tmp == tmp[::-1]:
			ans = 'Yes'
print(ans)


S = input()
N = len(S)

def f(s):
	return s == s[::-1]
print('YNeos'[not (f(S) and f(S[:(N - 1) // 2]) and f(S[(N + 3) // 2 - 1:]))::2])


s = input()
d = len(s) // 2
print('Yes' if s[:d] == s[d + 1:] else 'No')


s = input()
if s == s[::-1] and s[:(len(s) - 1) // 2] == s[(len(s) + 3) // 2 - 1:]:
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
S1 = S[0:(N - 1) // 2]
S2 = S[(N + 3) // 2 - 1:]
print('Yes' if S == S[::-1] and S1 == S1[::-1] and (S2 == S2[::-1]) else 'No')


s = input()
n = len(s)
h = n // 2
f = s[:h]
e = s[:-h - 1]
if s == s[::-1] and f == f[::-1] and (e == e[::-1]):
	print('Yes')
else:
	print('No')


s = input()
n = len(s) + 1
a = s[0:int((n - 1) / 2)]
b = s[int((n + 3) / 2) - 1:n - 1]
if a == b:
	print('Yes')
else:
	print('No')


s = list(input())
s_front = s[:len(s) // 2]
s_back = s[::-1][:len(s) // 2]
result = 'Yes'
for (f, f_r, b, b_r) in zip(s_front, s_front[::-1], s_back, s_back[::-1]):
	if f != f_r or b != b_r or f != b:
		result = 'No'
print(result)


s = input()
l = len(s)

def check(a):
	n = len(a)
	if n % 2 == 0:
		for i in range(n // 2):
			if a[i] != a[n - i - 1]:
				return False
		return True
	else:
		for i in range((n - 1) // 2):
			if a[i] != a[n - i - 1]:
				return False
		return True
res = 'No'
if check(s):
	if check(s[:(l - 1) // 2]):
		if check(s[(l + 3) // 2 - 1:]):
			res = 'Yes'
print(res)


s = input()
n = len(s)
x = n // 2
a = s[0:x]
b = s[x + 1:]
if a == b:
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
A = S[0:(N - 1) // 2]
B = S[(N + 3) // 2 - 1:N]
T = S[::-1]
print('Yes' if A == B and S == T else 'No')


a = input()
le = len(a)
if a[0:int(le / 2)] == a[int(le / 2) + 1:le]:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
s1 = s[0:(n - 1) // 2]
s2 = s[(n + 3) // 2 - 1:]
if s == s[::-1] and s1 == s1[::-1] and (s2 == s2[::-1]):
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
if s == s[::-1]:
	check = s[0:(n - 1) // 2]
	if check == check[::-1]:
		check = s[(n + 3) // 2 - 1:]
		if check == check[::-1]:
			print('Yes')
			return
print('No')


s = input()
f = s[:(len(s) - 1) // 2]
print('Yes' if s == s[::-1] and f == f[::-1] else 'No')


S = input()
N = len(S)

def is_palindrome(s):
	return s == ''.join(list(reversed(s)))
ans = 'Yes' if is_palindrome(S) and is_palindrome(S[:(N - 1) // 2]) and is_palindrome(S[(N + 1) // 2:]) else 'No'
print(ans)


s = input()
if 4 < len(s) < 6:
	print('No')
	return
if s[::-1] != s:
	print('No')
	return
s = s[:len(s) // 2]
if s[::-1] != s:
	print('No')
	return
print('Yes')


S = input()
H = len(S) // 2
if S[:H] == S[-H:] and S[:H] == S[-H:][::-1]:
	print('Yes')
else:
	print('No')


S = input()
t = len(S)
print('YNeos'[sum((1 for i in range(t) if S[i] != S[~i])) != 0 or S[(t + 2) // 2:] != S[:(t - 1) // 2]::2])


S = input()
N = len(S)
l = S[0:(N - 1) // 2]
r = S[(N + 3) // 2 - 1:]
if l == r:
	print('Yes')
else:
	print('No')


S = input()
n = len(S) // 2
if S[:n] == S[n + 1:]:
	print('Yes')
else:
	print('No')


s = list(input())
n = len(s)
s1 = s[0:(n - 1) // 2]
s2 = s[(n - 1) // 2 + 1:n]
sr = list(reversed(s))
s1r = list(reversed(s1))
s2r = list(reversed(s2))
if s == sr and s1 == s1r and (s2 == s2r):
	print('Yes')
	return
print('No')


S = input()
n = len(S)
a = S[:int((n - 1) / 2)]
b = S[int((n + 1) / 2):]
if a == b:
	print('Yes')
else:
	print('No')


s = input()
l = len(s)
if list(s)[:(l - 1) // 2] == list(s)[(l + 1) // 2:] == list(s)[:(l - 1) // 2:-1]:
	print('Yes')
else:
	print('No')


a = input()
b = len(a)
c = (b - 1) / 2
d = (b + 1) / 2
if a[:int(c)] == a[int(d):]:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
n2 = n // 2
print('Yes' if s[:n2] == s[:n2][::-1] == s[-n2:] else 'No')


def isParindrome(s):
	return s == s[::-1]
string = input()
ans = True
if not isParindrome(string):
	ans = False
if not isParindrome(string[(len(string) + 1) // 2:]):
	ans = False
if ans:
	print('Yes')
else:
	print('No')


S = input()
print('Yes' if S == S[::-1] and S[:int((len(S) - 1) / 2)] == S[:int((len(S) - 1) / 2)][::-1] else 'No')


S = input()

def isKaibun(s1):
	s2 = ''
	i = len(s1)
	while i > 0:
		i -= 1
		s2 += s1[i]
	if s1 == s2:
		return True
	return False
con1 = isKaibun(S)
con2 = isKaibun(S[:(len(S) - 1) // 2])
con3 = isKaibun(S[(len(S) + 3) // 2 - 1:])
if con1 and con2 and con3:
	print('Yes')
else:
	print('No')


s = list(input())
n = len(s)
print('Yes') if s[:(n - 1) // 2] == s[(n + 1) // 2:] else print('No')


N = str(input())
lenN = len(N)
fN = N[0:(lenN - 1) // 2]
lN = N[(lenN + 3) // 2 - 1:]
print(('No', 'Yes')[(0, 1)[fN == fN[-1::-1]] * (0, 1)[lN == lN[-1::-1]] * (0, 1)[lN == fN]])


s = input()
s1 = s[:len(s) // 2]
s2 = s[:len(s) // 2:-1]
s3 = s[len(s) // 2 + 1:]
if s1 == s2 == s3:
	print('Yes')
else:
	print('No')


s = input()
div = len(s) // 2
pre = s[:div]
post = s[div + 1:]
print('Yes' if pre == post else 'No')


def main():
	s = input()
	n = len(s)
	for i in range(n // 2):
		if s[i] != s[n - 1 - i]:
			print('No')
			return
	s1 = s[:(n - 1) // 2]
	s2 = s[(n + 3) // 2 - 1:]
	n1 = len(s1)
	for i in range(n // 4):
		if s1[i] != s[n1 - 1 - i]:
			print('No')
			return
		if s2[i] != s[n1 - 1 - i]:
			print('No')
			return
	print('Yes')

def __starting_point():
	main()
__starting_point()


s = input()
if s == s[::-1]:
	f = s[:len(s) // 2]
	b = s[len(s) // 2 + 1:]
	if f == f[::-1] and b == b[::-1]:
		print('Yes')
		return
print('No')


s = input()
l = len(s)
if s == s[::-1] and s[:(l - 1) // 2] == s[(l - 1) // 2 - 1::-1]:
	print('Yes')
else:
	print('No')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, bisect
from operator import itemgetter
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
stdin = sys.stdin
ni = lambda : int(ns())
nf = lambda : float(ns())
na = lambda : list(map(int, stdin.readline().split()))
nb = lambda : list(map(float, stdin.readline().split()))
ns = lambda : stdin.readline().rstrip()

def judge(S):
	for i in range(len(S) // 2):
		if S[i] != S[-(i + 1)]:
			return False
	return True
S = ns()
N = len(S)
p = S[:(N - 1) // 2]
l = S[(N + 3) // 2 - 1:]
if judge(S) and judge(p) and judge(l):
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
flag = False

def palind(S):
	size = len(S)
	for i in range(size // 2):
		if S[i] != S[-1 - i]:
			return False
	return True
if palind(s):
	m = (n - 1) // 2
	sb = s[:m]
	if palind(sb):
		sa = s[m + 1:]
		flag = palind(sa)
print('Yes' if flag else 'No')


def P(s):
	return s == s[::-1]
S = list(input())
N = len(S)
print('Yes' if P(S) and P(S[:N // 2]) and P(S[N // 2 + 1:]) else 'No')


n = input()
leng = len(n)
a = n[0:leng // 2]
b = n[(leng + 3) // 2 - 1:]
if n == n[::-1] and a == a[::-1] and (b == b[::-1]):
	print('Yes')
else:
	print('No')


s = list(input())
n = len(s)
flag = 0
for i in range(n // 2):
	if s[i] != s[n - i - 1]:
		flag = 1
if flag == 0:
	s2 = s[:(n - 1) // 2]
	n2 = len(s2)
	for i in range(n2 // 2):
		if s2[i] != s2[n2 - i - 1]:
			flag = 1
if flag == 0:
	if flag == 0:
		s2 = s[(n + 3) // 2 - 1:]
		n2 = len(s2)
	for i in range(n2 // 2):
		if s2[i] != s2[n2 - i - 1]:
			flag = 1
if flag == 0:
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
ans = sum([i == i[::-1] for i in [S, S[:(N - 1) // 2], S[(N + 3) // 2 - 1:]]])
print('Yes' if ans == 3 else 'No')


import math
import sys

class Graph:

	def __init__(self, Nodes, is_directed=False):
		self.nodes = Nodes
		self.adj_list = {}
		self.is_directed = is_directed
		for node in self.nodes:
			self.adj_list[node] = []

	def add_edge(self, u, v):
		self.adj_list[u].append(v)
		if self.is_directed == False:
			self.adj_list[v].append(u)

	def print_graph(self):
		for node in self.nodes:
			print((node, '->', self.adj_list[node]))

	def degree_node(self, node):
		return len(self.adj_list[node])

	def dfsUTIL(self, v, visited, parents=[]):
		visited[v] = True
		for i in self.adj_list[v]:
			if visited[i] == False:
				self.dfsUTIL(i, visited, parents)
				parents.append(i)

	def dfs(self, v):
		visited = [False] * (max(self.adj_list) + 1)
		parents = [v]
		self.dfsUTIL(v, visited, parents)
		return len(parents)

def dict_sort(ans):
	ans = sorted(list(ans.items()), reverse=True, key=lambda kv: kv[1])

def is_prime(n):
	if n == 1:
		return 0
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			return False
	return True

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def seive_primes(n):
	flag = [0] * (n + 10)
	flag[1] = flag[0] = 1
	i = 2
	while i * i <= n + 1:
		if flag[i] == 0:
			j = i * i
			while j <= n + 1:
				flag[j] = 1
				j += i
		i += 1
	return flag

def factors(n):
	d = {}
	while n % 2 == 0:
		if 2 in d:
			d[2] += 1
		else:
			d[2] = 1
		n /= 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		while n % i == 0:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
			n /= i
	n = int(n)
	if n > 1:
		d[n] = 1
	return d

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def alphabates():
	return 'abcdefghijklmnopqrstuvwxyz'

def binary_search(ls, n, flag):
	low = 0
	hi = n - 1
	while low <= hi:
		mid = (low + hi) // 2
		if ls[mid] == flag:
			return mid
		elif ls[mid] > flag:
			hi = mid - 1
		else:
			low = mid + 1
	return -1

def qdrt(a, b, c):
	chk = b * b - 4 * a * c
	if chk >= 0:
		ans1 = (-b + chk ** 0.5) / (2 * a)
		ans2 = (-b - chk ** 0.5) / (2 * a)
		return [int(ans1), int(ans2)]
	return -1

def permutation(n, r):
	if n < r:
		return 0
	ans = 1
	for i in range(n - r + 1, n + 1):
		ans *= i
	return ans

def combination(n, r):
	if n < r:
		return 0
	ans = 1
	for i in range(r):
		ans *= n - i
	div = 1
	for i in range(2, r + 1):
		div *= i
	return ans // div

def arinp():
	ls = list(map(int, input().split()))
	return ls

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

def main():
	s = input()
	n = len(s)
	if s == s[::-1] and s[:n // 2] == s[n // 2 + 1:]:
		print('Yes')
	else:
		print('No')

def __starting_point():
	main()
__starting_point()


s = input()
print(' YNeos'[s[:len(s) // 2] in s[2:]::2])


s = input()
print('YNeos'[s.count(s[:len(s) // 2]) < 2::2])


S = str(input())
forward = ''
back = ''
for i in range(0, (len(S) - 1) // 2):
	forward += S[i]
for j in range((len(S) + 3) // 2 - 1, len(S)):
	back += S[j]
if forward == back:
	print('Yes')
else:
	print('No')


kai = input()
num = len(kai)
ans = 0
n1 = int((num - 1) / 2)
for i in range(n1):
	if kai[i] != kai[-1 * (i + 1)]:
		ans += 1
l1 = kai[0:n1]
for i in range(len(l1)):
	if l1[i] != l1[-1 * (i + 1)]:
		ans += 1
l2 = kai[n1 + 1:]
for i in range(len(l2)):
	if l2[i] != l2[-1 * (i + 1)]:
		ans += 1
if ans == 0:
	print('Yes')
else:
	print('No')


s = input()
left = s[:len(s) // 2]
right = s[len(s) // 2 + 1:]
if left == right:
	print('Yes')
else:
	print('No')


S1 = input()
N = len(S1)
S2 = S1[::-1]
a = S1 == S2
S3 = S1[:int((N - 1) / 2)]
S4 = S3[::-1]
b = S3 == S4
S5 = S1[int((N + 3) / 2) - 1:]
S6 = S5[::-1]
c = S5 == S6
if a and b and c:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
s1 = s[:(n - 1) // 2]
s2 = s[(n + 3) // 2 - 1:n]
if s != s[::-1] or s1 != s1[::-1] or s2 != s2[::-1]:
	print('No')
else:
	print('Yes')


S = input()
rS = S[::-1]
le = len(S)
cent = int((le + 1) / 2)
S1 = S[0:cent - 1]
S2 = S[cent:]
rS1 = S1[::-1]
rS2 = S2[::-1]
if S == rS and S1 == rS1 and (S2 == rS2):
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
SH = S[:(N - 1) // 2]
ST = S[(N + 3) // 2 - 1:]
p = False
if SH == SH[::-1] and SH == ST:
	p = True
print('Yes' if p else 'No')


S = input()
S1 = S[:len(S) // 2]
S2 = S[len(S) // 2 + 1:]
print('Yes' if S1 == S2 and S1 == S1[::-1] else 'No')


import math
s = list(input())
n = len(s)
s1 = s[:(n - 1) // 2]
s2 = s[(n + 3) // 2 - 1:n]
flag = 1
for i in range(len(s) // 2):
	if s[i] != s[-i - 1]:
		flag = 0
for i in range(len(s1) // 2):
	if s1[i] != s1[-i - 1]:
		flag = 0
for i in range(len(s2) // 2):
	if s2[i] != s2[-i - 1]:
		flag = 0
print('Yes' if flag == 1 else 'No')


string = input()
palindrome = False
palin1 = False

def palin(string):
	palindrome = False
	if string == string[::-1]:
		palindrome = True
	return palindrome
palindrome = palin(string)
if palin(string[int((len(string) - 1) / 2)]) == True and palindrome == True:
	palin1 = True
if palin(string[int((len(string) + 3) / 2) - 1:len(string)]) == True and palin1 == True:
	print('Yes')
else:
	print('No')


S = input()
N = len(S)

def palindrome(string):
	return 0 if string == string[::-1] else 1
ls1 = S[0:int((N - 1) / 2)]
ls2 = S[int((N + 3) / 2 - 1):N]
if palindrome(S) == palindrome(ls1) == palindrome(ls2) == 0:
	print('Yes')
else:
	print('No')


S = input()
l = len(S) // 2
print('YNeos'[any(map(lambda s: any((c != d for (c, d) in zip(s, s[::-1]))), [S, S[:l], S[-l:]]))::2])


S = input()
N = len(S)
ret = 'Yes'
for (s1, s2) in list(zip(S, reversed(S)))[:N // 2]:
	if s1 != s2:
		ret = 'No'
		break
s = S[:N // 2]
for (s3, s4) in list(zip(s, reversed(s)))[:N // 4]:
	if s3 != s4:
		ret = 'No'
		break
print(ret)


s = input().strip()
(y, n) = ('Yes', 'No')
mid = len(s) // 2
if s[0:mid] == s[mid + 1:len(s)]:
	print(y)
else:
	print(n)


S = input()
c = len(S) // 2
print('Yes' if S[:c] == S[c + 1:] else 'No')


def check(string):
	if string == string[::-1]:
		return True
	else:
		return False
S = input()
n = len(S)
S1 = S[:(n - 1) // 2]
S2 = S[(n + 1) // 2:]
if check(S) and check(S1) and check(S2):
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
M = (N - 1) // 2
U = S[:M]
V = S[M + 1:]
if U != V or U != U[::-1]:
	print('No')
else:
	print('Yes')


def isp(s):
	return s == s[::-1]
s = input()
n = len(s) // 2
if isp(s) and isp(s[:n]):
	print('Yes')
else:
	print('No')


a = input()
b = len(a)
c = (b - 3) // 2
if a == a[::-1] and a[0:c] == a[c:0:-1]:
	print('Yes')
else:
	print('No')


S = input()
T = ''
U = ''
N = len(S)
for i in range((N - 1) // 2):
	T += S[i]
for i in range((N - 1) // 2 - 1, -1, -1):
	U += T[i]
if T == U:
	if S == T + S[(N - 1) // 2] + T:
		print('Yes')
		return
print('No')


s = input()
ls = s[:int((len(s) - 1) / 2)]
rs = s[int((len(s) - 1) / 2) + 1:]
if ls == rs:
	print('Yes')
else:
	print('No')


s = input()
for i in [s, s[:len(s) // 2], s[len(s) // 2 + 1:]]:
	if i != i[::-1]:
		print('No')
		break
else:
	print('Yes')


s = input()
n = len(s)
l1 = int((n - 1) / 2)
l2 = int((n + 3) / 2)
if s == s[::-1] and s[:l1] == s[l2 - 1:n]:
	print('Yes')
else:
	print('No')


S = list(input())
k = (len(S) - 1) // 2
T = S[0:k]
print('Yes' if S == S[::-1] and T == T[::-1] else 'No')


s = input()
num = len(s)
n1 = s[0:(num - 1) // 2]
n2 = s[(len(s) + 3) // 2 - 1:]
if s == s[::-1] and n1 == n1[::-1] and (n2 == n2[::-1]):
	print('Yes')
else:
	print('No')


s = input()
C = len(s) // 2
print('Yes' if s[:C] == s[C + 1:] else 'No')


s = input()
h = len(s) // 2
(l, r) = (s[:h], s[-h:])
print(['No', 'Yes'][s == s[::-1] and l == l[::-1] and (r == r[::-1])])


s = input()
n = len(s)
p = n // 2
q = (n + 1) // 2
kk = s[q:]
if s[0:p] == s[:p:-1] and kk == kk[::-1]:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)

def judge_palindrome(s):
	if s == s[::-1]:
		return True
	else:
		return False
if judge_palindrome(s) and judge_palindrome(s[:(n - 1) // 2]) and judge_palindrome(s[(n + 3) // 2 - 1:]):
	ans = 'Yes'
else:
	ans = 'No'
print(ans)


S = input()
ans = 'No'
if S == S[::-1] and S[:int((len(S) - 1) / 2)] == S[:int((len(S) - 1) / 2)][::-1] and (S[int((len(S) + 3) / 2) - 1:] == S[int((len(S) + 3) / 2) - 1:][::-1]):
	ans = 'Yes'
print(ans)


s = input()
first = s[:len(s) // 2]
second = s[len(s) // 2 + 1:]
if first == second:
	print('Yes')
else:
	print('No')


def tk(s):
	s1 = s[0:len(s) // 2 + 1]
	s2 = s[len(s) // 2:len(s)]
	if s1 == s2[::-1]:
		return True
	else:
		return False

def Kaibun(s):
	if s == s[::-1]:
		return True
	else:
		return False

def __starting_point():
	S = input()
	if tk(S) and Kaibun(S[0:len(S) // 2]) and Kaibun(S[len(S) // 2 + 1:len(S)]):
		print('Yes')
	else:
		print('No')
__starting_point()


import os, sys, re, math
S = input()
s1 = S[:(len(S) - 1) // 2]
s2 = S[(len(S) + 3) // 2 - 1:]
if S[::-1] == S and s1[::-1] == s1 and (s2[::-1] == s2):
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
s1 = S[:(N - 1) // 2]
s2 = S[(N + 1) // 2:]
if s1 == s2:
	print('Yes')
else:
	print('No')


S = list(input().rstrip())
l = int((len(S) - 1) / 2)
print('Yes') if S[:l] == S[-l:] else print('No')


s = input()
n = len(s)
a = len(s) // 4
if s[:n // 2] == s[n // 2 + 1:]:
	print('Yes')
else:
	print('No')


S = input()
l = len(S)
A = S[:l // 2]
B = S[l // 2 + 1:]
if A == B and A == B[::-1]:
	print('Yes')
else:
	print('No')


s = input()
x = len(s)
l = s[0:(x - 1) // 2]
r = s[(x + 3) // 2 - 1:]
print('Yes' if s == s[::-1] and l == l[::-1] and (r == r[::-1]) else 'No')


s = list(input())
N = len(s)
a = int((N - 1) / 2)
b = int((N + 1) / 2)
if s[::-1] == s and s[:a] == s[b:]:
	print('Yes')
else:
	print('No')


S = input()
Skai1 = S[0:(len(S) - 1) // 2]
Skai1 = Skai1[::-1]
Skai2 = S[(len(S) + 3) // 2 - 1:len(S)]
Skai2 = Skai2[::-1]
if S == S[::-1] and S[0:(len(S) - 1) // 2] == Skai1 and (S[(len(S) + 3) // 2 - 1:len(S)] == Skai2):
	print('Yes')
else:
	print('No')


s = input()
a = s[::-1]
n = len(s)
ans = 'Yes'
if s != a:
	ans = 'No'
elif s[:(n - 1) // 2] != s[(n + 3) // 2 - 1:]:
	ans = 'No'
print(ans)


S = input()
pre = (len(S) - 1) / 2
post = (len(S) + 3) / 2
if S[0:int(pre)] == S[int(post) - 1:]:
	print('Yes')
else:
	print('No')


S = input()
N = len(S)
S_f = S[:int((N - 1) / 2)]
S_b = S[int((N + 1) / 2):]
a = []
for i in range(int(len(S) / 2)):
	if S[i] == S[len(S) - i - 1]:
		a.append(0)
	else:
		a.append(1)
for i in range(int(len(S_f) / 2)):
	if S_f[i] == S_f[len(S_f) - i - 1]:
		a.append(0)
	else:
		a.append(1)
for i in range(int(len(S_b) / 2)):
	if S_b[i] == S_b[len(S_b) - i - 1]:
		a.append(0)
	else:
		a.append(1)
if sum(a) == 0:
	print('Yes')
else:
	print('No')


s = input()
n = len(s)
check = True
for i in range(n):
	if s[i] != s[n - i - 1]:
		check = False
for i in range((n - 1) // 2):
	if s[i] != s[(n - 1) // 2 - i - 1]:
		check = False
	if s[i + (n + 1) // 2] != s[n - i - 1]:
		check = False
print('Yes' if check else 'No')


s = input()
if s[0:len(s) // 2] == s[len(s) // 2 + 1:len(s)]:
	print('Yes')
else:
	print('No')


s = input()
l = len(s)
okey = 1
ll = l // 2
for i in range(0, l // 2):
	if s[i] != s[l - i - 1]:
		okey = 0
		break
if okey == 1:
	for i in range(0, ll // 2):
		if s[i] != s[ll - i - 1]:
			okey = 0
			break
if okey == 1:
	for i in range(ll + 1, ll + ll // 2):
		if s[i] != s[l - i - 1]:
			okey = 0
			break
if okey == 1:
	print('Yes')
else:
	print('No')


kaibunkai = input()
n = len(kaibunkai)
zenhan = kaibunkai[:(n - 1) // 2]
kouhan = kaibunkai[(n + 3) // 2 - 1:]

def kaibun_desuka(bun):
	s = len(bun)
	for x in range(s // 2):
		if bun[x] != bun[-x - 1]:
			return False
	return True
if kaibun_desuka(kaibunkai) and kaibun_desuka(zenhan) and kaibun_desuka(kouhan):
	print('Yes')
else:
	print('No')


s = input()
N = len(s)
t = s[::-1]
a = s[0:int((N - 1) / 2)]
b = a[::-1]
if s == t and a == b:
	print('Yes')
else:
	print('No')


S = str(input())
s = list(map(str, S))
N = len(s)
t = 0
for i in range(int((N - 1) / 2)):
	if s[i] != s[N - i - 1]:
		t += 1
		break
for i in range(int((N - 1) / 4)):
	if s[i] != s[int((N - 1) / 2) - i - 1]:
		t += 1
		break
if t == 0:
	print('Yes')
else:
	print('No')


x = input()
n = len(x)
if x[:int((n - 1) / 2)] == x[int((n + 3) / 2) - 1:]:
	print('Yes')
else:
	print('No')


def main():
	S = input()
	N = len(S)
	S1 = S[0:(N - 1) // 2]
	S2 = S[(N + 3) // 2 - 1:]
	if S == S[::-1] and S1 == S1[::-1] and (S2 == S2[::-1]):
		print('Yes')
	else:
		print('No')

def __starting_point():
	main()
__starting_point()


S = input()
N = len(S)

def isPalindrome(s):
	n = len(s)
	flag = True
	slist = list(s)
	for (i, c) in enumerate(slist):
		if c != slist[n - 1 - i]:
			flag = False
		if i > n - i:
			break
	return flag
Slist = list(S)
if isPalindrome(S) and isPalindrome(Slist[0:int((N - 1) / 2)]) and isPalindrome(Slist[int((N + 3) / 2) - 1:N]):
	print('Yes')
else:
	print('No')


S = input()
halfS = str(S[0:int(len(S) / 2)])
ans = 'No'
if S == S[::-1]:
	if halfS == halfS[::-1]:
		ans = 'Yes'
print(ans)


S = input()
N = len(S)
SS = S[0:(N - 1) // 2]
SSS = S[(N + 1) // 2:N + 1]
for i in range((N - 1) // 2):
	if S[i] != S[-1 - i]:
		print('No')
		return
	if SS[i] != SS[-1 - i]:
		print('No')
		return
	if SSS[i] != SSS[-1 - i]:
		print('No')
		return
print('Yes')


S = input()
N = len(S)
S_1 = S[:int((N - 1) // 2)]
S_2 = S[int((N + 2) // 2):]
if S == S[::-1] and S_1 == S_1[::-1] and (S_2 == S_2[::-1]):
	print('Yes')
else:
	print('No')


S = input()
N = len(S) // 2
print('Yes' if S[:N] == S[-N:] else 'No')


def is_kaibun(string):
	for i in range(len(string) // 2 + 1):
		if string[i] != string[len(string) - i - 1]:
			return False
	else:
		return True
S = input()
if is_kaibun(S) and is_kaibun(S[0:(len(S) - 1) // 2]) and is_kaibun(S[(len(S) + 3) // 2 - 1:len(S)]):
	print('Yes')
else:
	print('No')


s = input()
d = len(s)
n = int((d - 1) / 2)
for i in range(n):
	x = int((d - 3) / 2 - i)
	if s[i] == s[d - i - 1] == s[x]:
		continue
	else:
		print('No')
		return
print('Yes')


s = input()
n = len(s)
ans = 'Yes'
if s[:(n - 1) // 2] != s[(n + 1) // 2:] or s[:(n - 1) // 2] != s[(n - 3) // 2::-1]:
	ans = 'No'
print(ans)


s = list(input())
n = len(s)
a = int((n - 1) / 2)
b = int((n + 3) / 2)
for i in range(a):
	if s[i] != s[n - 1 - i]:
		print('No')
		return
for i in range(a):
	if s[i] != s[a - 1 - i]:
		print('No')
		return
for i in range(a):
	if s[b + i - 1] != s[n - 1 - i]:
		print('No')
		return
print('Yes')


S = input()
N = len(S)
ans = 'No'
if S == S[::-1]:
	if S[:N // 2] == S[N // 2 - 1::-1]:
		ans = 'Yes'
print(ans)


def readinput():
	s = input()
	return s

def isKaibun(s):
	i = 0
	j = len(s) - 1
	while i <= j:
		if s[i] != s[j]:
			return False
		else:
			i += 1
			j -= 1
	return True

def main(s):
	if not isKaibun(s):
		return 'No'
	n = len(s)
	m = (n - 1) // 2
	l = (n + 3) // 2
	if not isKaibun(s[:m]):
		return 'No'
	if not isKaibun(s[l - 1:]):
		return 'No'
	return 'Yes'

def __starting_point():
	s = readinput()
	ans = main(s)
	print(ans)
__starting_point()


s = input()
str2 = s[0:(len(s) - 1) // 2]
str3 = s[(len(s) + 3) // 2:len(s) - 1]
if s == ''.join(list(reversed(s))) and str2 == ''.join(list(reversed(str2))) and (str3 == ''.join(list(reversed(str3)))):
	print('Yes')
else:
	print('No')


S = input()
print('YNeos'[S != S[::-1] or 1 - S.endswith(S[:len(S) // 2])::2])