peterverebics/CodeNet_Python_118 huggingface dataset:
s = input()
x = s[::-1]

y = s[0:3]
a = y[::-1]

z = s[4:6]
b = z[::-1]

if list(s) == list(x) and list(y) == list(a) and list(z) == list(b):
	print("Yes")
else:
	print("No")
S=input()
ans=1
for i in range(len(S)//2):
    
    if S[i]==S[len(S)-1-i]:
        ans*=1
    else:
        ans*=2

for j in range((len(S)-1)//4):
    
    if S[j]==S[len(S)//2-1-j]:
        ans*=1
    else:
        ans*=3

if ans==1:
    print("Yes")
else:
    print("NO")
S = input()
S_rvs = S[::-1]
N = len(S)
left = int((N-1)/2-1)
right = int((N+3)/2-1)

if S == S_rvs and S[:left] == S_rvs[right:] and S[right:] == S_rvs[:left]:
    print("Yes")
else:
    print("No")
import sys
def input(): return sys.stdin.readline().rstrip()

S = input()
mid = len(S)//2
fst = S[:mid]
lat = S[mid+1:]
if fst == lat[::-1]:
    mid = len(fst)//2
    fst_2 = fst[:mid]
    lat_2 = fst[mid+1:]
    if fst_2 == lat_2[::-1]:
        fst_3 = lat[:mid]
        lat_3 = lat[mid+1:]
        if fst_3 == lat_3[::-1]:
            print('Yes')
        else:
            print('No')
    else:
        print('No')
else:
    print('No')
s = str(input())

ans = 0

def kaibun(tex):
  n = len(tex)
  before = tex[0:int((n-1)/2)]
  after = tex[int((n+3)/2-1):]
  if before == after:
    return 1
  else:
    return 0
    
ans += kaibun(s)
ans += kaibun(s[0:int((len(s)-1)/2)])
ans += kaibun(s[int((len(s)+3)/2-1):])

if ans == 3:
  print('Yes')
else:
  print('No')
data = input()

length = len(data)

half = int((length-1)/2)

if data[:half] == data[half+1:]:
    data_2 = data[:half]
    length = len(data_2)
    
    if length%2 == 0:
        print('No')
        exit()
    
    half = int((length-1)/2)
    if data_2[:half] == data_2[half+1:]:
        print('Yes')
        exit()
print('No')
import numpy as np
import fractions
import decimal
from collections import deque

s=str(input())
a=s[:(len(s)-1)//2]
# print(a)
if(a!=a[::-1]):
    print("No")
    exit(0)
b=s[(len(s)+3)//2-1:]
# print(b)akasaka
if(b!=b[::-1]):
    print("No")
    exit(0)

print("Yes")
S = input()

num = len(S)
S1 = S[:(num-1)//2]
S2 = S[(num+3)//2:]

if S == S[::-1] and S1 == S1[::-1] and S2 == S2[::-1]:
  print('Yes')
else:
  print('No')
def main():
  
  strInput = input()
  
  if len(strInput) < 3 or len(strInput) > 99 \
  	or strInput.isupper() or (strInput.isalpha() == True):
    return print('No\n')
  
  if len(strInput) % 2 != 0:
    return print('No\n')
  
  strInputReverse = ''.join(list(reversed(strInput)))
  
  if strInput == strInputReverse:
    return print('Yes\n')
  else:
    return print('No\n')

if __name__ == '__main__':
  main()
s=input()

def kai(s):
    if len(s)%2 == 0:
        if s[:int(len(s)/2)] == s[int(len(s)/2):]:
            return True
        else:
            return False

    else:
        if s[:int((len(s)-1)/2)] == s[int((len(s)+1)/2):]:
            return True
        else:
            return False

if kai(s) and kai(s[:int((len(s)-1)/2)]) and kai(s[int((len(s)+1)/2):]):
    print('Yes')
else:
    print('No')
S = input()
N = len(S)
p1 = S[0:(N-1)//2]
p2 = S[(N+2)//2:]
if p1 == p1[::-1] and p2 == p2[::-1]:
    print('Yes')
else:
    print('No')
s=input()
l=int(len(s))
print(l)
ss=s[0:int((l-1)/2)]
sl=s[int((l+1)/2):l]
l1=int(len(ss))

s0=ss[0:int((l1-1)/2)]
s1=''.join(reversed(list(ss[int((l1+1)/2):l])))

if ss == sl and s0 == s1:
    print('Yes')
else:
    print('No')
def palindrome(S):
    S1 = list(S)
    S1.reverse()
    S2 = "".join(S1)


    if S == S2:
        return "Yes"
    else:
        return "No"
s = input()
n = len(s)
a = s[:(n-1)//2-1]
b = s[-(n+3)//2:]

t = s[::-1]
c = t[:(n-1)//2-1]
d = t[-(n+3)//2:]
if (a==b) and (b==c) and (c==d) and (d==a):
  print('Yes')
else:
  print('No')
S = input()
N = len(S)
isPal = lambda s: s == s[::-1]
print("Yes" if isPal(S[:(N-1)//2]) and isPal(S[(N-1)//2:]) else "No")
st=input()
def iskaibun(s):
  print(s)
  if(s==""):
      return 1;
  else:
      if(s[0]==s[-1]):
          return iskaibun(s[1:-1])
      else:
          return 0

l = len(st)
q = (l-1)//2
st1 = st[0:q]

st2 = st[q+1:]

if(st1 == st2[-1] and iskaibun(st1)==1 and iskaibun(st2)==1):
    print("Yes")
else:
    print("No")
s = input()
l = len(s)
if list(s) != list(reversed(s)):
    print('No')
    exit()
if list(s[:l - 1 // 2]) != list(reversed(s[:l - 1 // 2])):
    print('No')
    exit()
if list(s[l + 3 // 2:l]) != list(reversed(s[l + 3 // 2:l])):
    print('No')
    exit()
print('Yes')
a = input()
c = len(a)//2
if c == 1:
  print('Yes')
  exit()
for i in range(c//2):
  if a[i] != a[(len(a)-1)//2-1-i]:
    print('No')
    exit()
  if a[-c] != a[-1-i]:
    print('No')
    exit()
print('Yes')
s = input()
n = len(s)
s1 = s[:int((n-1)/2)]
s2 = s[int((n+3)/2)-1:]


i = 1
while i < len(s1):
    if not s1[i-1] == s1[-i]:
        print("No")
        exit()
    i += 1
while i < len(s2):
    if not s2[i+2] == s2[-i]:
        print("No")
        exit()
    i += 1
print("Yes")
def isKaibun(s):
  for a, b in zip(s, reversed(s)):
    if a != b:
      return False
  return True

S = list(input())
N = len(S)
if isKaibun(S[:(N-1)//2]) and isKaibun(S[2+(N+1)//2:]):
  print("Yes")
else:
  print("No")
s = input()
n = len(s)

ans = 'Yes'

if n == 3:
    if s[0] != s[2]:
        ans = 'No'
else:
    for i in range(int((n-1) / 4)):
        if s[i] != s[int((n-3) / 2 - i)]:
            ans = 'No'
            break
        elif s[int((n+1) / 2 + i)] != s[-(i+1)]:
            ans = 'No'
            break

print(ans)
s = list(str(input()))

ans = 0
n = len(s)
s1 = list(reversed(s))
if s != s1:
    ans = 1

s2 = s[0:(n-1)//2]
s3 = list(reversed(s2))
if s2 != s3:
    ans = 1

s4 = s[(n+2)//2:n]
s5 = list(reversed(s4))
if s4 != s5:
    ans = 1

print(s,s1,s2,s3,s4,s5)

if ans == 0:
    print('Yes')
else:
    print('No')
def f(x):
	return x == x[::-1]
S = input()


l1 = (len(S)-1)//2
l2 = (len(S)+3)//2

S1 = S[:l1]
S2 = S[l2-1:]


print(S1,S2)
if f(S) and f(S1) and f(S2):
	print("Yes")
else:
	print("No")
S = list(input())
N = len(S)

out = "Yes"
for i in range(int((N-1)/4)):
    if S[i] == S[int((N-1)/2)-i-1]:
        pass
    elif S[i] != S[int((N-1)/2)-i-1]:
        out = "No"
        break
    else:
        pass
        
    if S[int((N+3)/2)-i-1] == S[-i]:
        pass
    else:
        out = "No"
        break
print(out)
S = input()
n = len(S)
check = True
if (n-1) % 4 == 0:
  print("No")
  exit()
half = (n-1)/2
zen, kou = [], []
for i in range(0, int((n-1)/2)):
  j = int((n-1)/2+i)+1
  zen.append(S[i])
  kou.append(S[j])
p = len(zen)
q = len(kou)
for i in range(p):
  if zen[i] != zen[p-i-1]:
    check = False
for i in range(q):
  if kou[i] != zen[q-i-1]:
    check = False
if check:
  print("Yes")
else:
  print("No")
s=input()
n=len(s)
s1=s[:n//2]
s2=s[n//2+1:]
test =True
if(s!=s[::-1]):
	test=False
if (s1!=s1[::-1]):
	test=False
if(s2!=s2[::-1]):
	test=False
if(test==True):
	print("YES")
else:
	print("NO")
def kaibunCheck(s):
  flag = True
  if len(s) % 2 == 1:
    n = len(s)
    for i in range((n + 1) // 2):
      if s[i] != s[(i + 1) * (-1)]:
        flag = False
  else:
    flag = False
    
  return flag
        
S = input()
N = len(S)

S1 = S[:(N - 1) // 2]
S2 = S[(N + 1) // 2 :]

if kaibunCheck(S) == True and kaibunCheck(S1) == True and kaibunCheck(S2) == True:
  print("Yes")
else:
  print("No")
wholeString = input()
firstSub = wholeString[0:int((len(wholeString)-1)/2)]
secondSub = wholeString[int(((len(wholeString)+3)/2)-1):]
if firstSub == firstSub[::-1] and secondSub == secondSub[::-1]:
  print("Yes")
else:
  print("No")
S=input()
N=len(S)
Ans='Yes'
        
if S[:int((N-1)/2)]!=S[:int((N-1)/2):-1]:
    Ans='No'
    
if int((N-1)/2)%2==0:
    if S[:int((N+3)/4)]==S[:int((N+3)/4):-1]:
        Ans='No'
        
else:
    if S[:int((N+1)/4)]==S[:int((N+1)/4):-1]:
        Ans='No'
    
print(Ans)
s = input()
n = len(s)
a = s[0:(n-1)//2]
b = s[(n+3)//2:-1]
if a == a[::-1] and b == b[::-1]:
    print("Yes")
else:
    print("No")
def kaibun(s):
    flg = False
    if len(s) % 2 == 0:
        if s[0:int((len(s)/2)-1)] == s[int(len(s)/2):len(s)-1]:
            flg =True
    else:
        if s[0:int((len(s)-1)/2-1)] == s[int((len(s)+1)/2):len(s)-1]:
            flg =  True
    return flg



s = input()
ans = "No"



if kaibun(s):
    if kaibun(s[0:int((len(s)-1)/2-1)]) and kaibun(s[int((len(s)+1)/2):len(s)-1]):
        ans = "Yes"
print(ans)
s = input()
cnt = 0
if len(s) < 7:
    print("No")
    exit()
else:
    
    for i in range(len(s) // 2):
        if s[i] == s[len(s) - i - 1]:
            cnt += 1
    if cnt == len(s) // 2:
        print("Yes")
    
    else:
        print("No")
s = input()
l = len(s)
if list(s) != list(reversed(s)):
    print('No')
    exit()
if list(s[:l - 1 // 2]) != list(reversed(s[:l - 1 // 2])):
    print('No')
    exit()
if list(s[l + 3 // 2 -1:l]) != list(reversed(s[l + 3 // 2 -1:l])):
    print('No')
    exit()
print('Yes')
s = input()
for i in range(1,len(s)):
  if (s[i-1]!=s[-i]):
    print("No")
print("Yes")
S = input()


def check(s):
    flag = False
    for i in range(len(s)//2):
        if s[i] != s[-i-1]:
            break
        flag = True
    return(flag)


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

result = 'Yes'
j = int((len(s)-1)/2)
for i in range(int(j/2)):
    if(s[i] != s[j-i-1]):
        result = 'No'
        break

for i in range(j+1,j+int(j/2)):
    if(s[i] != s[len(s)-i-1]):
        result = 'No'
        break

print(result)
s = input()
n = len(s)//2
if s[:n] == s[:n][::-1] and s[n+1:] == s[n+1:][::-1]:
    print('Yes')
else:
    print('No')
# coding: utf-8

s = input()
n = len(s)
ss = s[:(n-1)//2]
for i in range((n-1)//4):
    if not ss[i] == ss[-1*(i+1)]:
        print('No')
        break
else:
    print('Yes')
S = input()
first = S[:int((len(S)-1)/2)]
second = S[int((len(S)+3)/2-1):]
if first == ''.join(list(reversed(first))) and second == ''.join(list(reversed(second))):
    print('Yes')
else:
    print('No')
def ispalindrome(s):
	print(s)
	l=len(s)
	for i in range(l//2):
		if s[i]!=s[l-i-1]:
			return False
	return True
s=input()
l=len(s)
if ispalindrome(s) and ispalindrome(s[:l//2]) and ispalindrome(s[(l+1)//2:]):
	print("Yes")
else:
	print("No")
S=input()
N=len(S)
s=''.join(list(reversed(S)))

T=S[0:int((N-1)/2)]
NT=len(T)
t=''.join(list(reversed(T)))

U=S[int((N+1)/2):N]
NU=len(U)
u=''.join(list(reversed(U)))

if S[0:int((N-1)/2)] == s[0:int((N-1)/2)] and T[0:int((NT-1)/2)] == t[0:int((NT-1)/2)] and U[0:int((NU-1)/2)] == u[0:int((NU-1)/2)]:
    print('Yes')
else:
    print('No')
def palindrome(s):
    return s == s[::-1]

def judge(s):
    return palindrome(s) and palindrome(s[0:len(s)-1//2]) and palindrome(s[len(s)-1//2:])

S = input()
print('Yes' if judge(S) else 'No')
letters = input()

def kaibun_check(letters):
    count = 0
    if len(letters)%2 == 0 or len(letters)<0:
        return False
    for _ in range(len(letters)//2):
        count += 1
        if letters[count-1] != letters[-count]:
            return False
    return True

if kaibun_check(letters) and kaibun_check(letters[:(len(letters)-1)//2]) and kaibun_check(letters[(len(letters)+3)//2-1:]):
    print('Yes')
else:
    print('No')
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

# map(int, input().split())
# list(map(int, input().split()))

S = input()
N = len(S)

l = S[:(N-1)//2]
r = S[(N + 3)//2 + 1:]

if S == S[::-1] and l == l[::-1] and r == r[::-1]:
    print("Yes")
else:
    print("No")
S = input()
S2 = S[:(len(S)-1)//2]
S3 = S[(len(S)+3)//2-1:]
print(S2, S3)
print("Yes" if S == S[::-1] and S2 == S2[::-1] and S3 == S3[::-1] else "No")
S = input()

def kaibun(x):
    N = len(x)
    flag = True
    for i in range(N // 2):
        if S[i] != S[-i - 1] or N < 3:
            flag = False
    return flag

tmp1 = kaibun(S)
tmp2 = kaibun(S[:(len(S) - 1) // 2])
tmp3 = kaibun(S[(len(S) + 3) // 2:])

if tmp1 and tmp2 and tmp3:
    print('Yes')
else:
    print('No')
S = input()
left = S[0:(len(S)-1)//2]
right = S[(len(S)+3)//2 - 1: len(S)]

def kaibun(s):
    for i in range(len(s)//2):
        if s[i] != s[len(s)-i-1]:
            return False
    return True

if kaibun(left) and kaibun(right):
    print('Yes')
else:
    print('No')
import sys
input = sys.stdin.readline


def main():
    S = input().strip()
    for i in range((len(S)-1)//2):
        if not (S[i] == S[(len(S)-1)//2-i-1] and S[(len(S)+3)//2+i-1] == S[len(S)-i-1]):
            print("No")
            exit()
    print("Yes")


if __name__ == '__main__':
    main()
S = input()
N = len(S)
def is_pali(s):
    for ind, i in enumerate(s[:len(s)//2]):
        if(i==s[-ind-1]):
            continue
        else:
            return False
    return True

if(is_pali(S) and is_pali(S[:(N-1)//2]) and is_pali(S[(N+3)//2+1:])):
    print('Yes')
else:
    print('No')
# list(map(int,input().split()))
# map(int,input().split())

S = list(input())
N = len(S)
flag = True
if N == 3: flag = False
for i in range((N-1)//4):
    if S[i] == S[(N-1)//2-1] and S[(N+3)//2-1] == S[N-1-i]:
        continue
    else:
        flag = False
        break

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


#C
x = input()
N = len(x)

x1 = x[0:(N-1)//2]
x2 = x[(N+3)//2-1:N]
if(x1 == ''.join(list(reversed(x1)))):
    if(x2 == ''.join(list(reversed(x2)))):
        print('Yes')
    else:
        print('No')
    
else:
    print('No')
n = input()
x = len(n)

if n == n[::-1]:
  if n[:((x-1)//2)] == n[:((x-1)//2)][::-1]:
    if n[:((x+3)//2)] == n[:((x+3)//2)][::-1]:
      print('Yes')
else:
  print('No')
S=input()
N=len(S)
c1=int((N-1)/2)
c2=int((N+3)/2)
S1=S[:c1]
r_S=S[::-1]
r_S1=S1[::-1]
S2=S[(c2-1):]
r_S2=S2[::-1]


#kaibun hantei
N_s=int((len(S)-1)/2)
N_s1=int((len(S1)-1)/2)
N_s2=int((len(S2)-1)/2)

if S1[:N_s]==r_S1[:N_s] and S1[:N_s1]==r_S1[:N_s1] and S2[:N_s2]==r_S2[:N_s2]:
  print("Yes")
else:
  print("No")
S = str(input())
N = len(S)

S1 = S[0:N//2]
S1_1=S1[0:len(S)//4]
S1_2=S1[len(S)//4:len(S)//2]


S2= S[N//2+1:]
S2_1=S2[0:len(S)//4]
S2_2=S2[len(S)//4:len(S)//2]


if S1_1 == S1_2 and S2_1 == S2_2:
    print("Yes")
else:
    print("No")
s=list(input())
k=0
q=0
n=len(s)
for i in range((n-1)//2):
  if s[i]==s[n-1-i]:
    k+=1
if k==(n-1)//2 and (n-1)%4!=0:
  for i in range((n-1)//4):
    if s[i]==s[(n-1)//2-1-i]:
      q+=1
  if q==(n-1)//4:
    print("Yes")
  else:
    print("No")
else:
  print("No")
s = input()

flag = True
n = len(s)
for i in range(n//4):
  if s[i] == s[(n-1)//2 -1 - i] == s[(n+3)//2 -1 + i] == s[n-1 - i]:
    continue
  else:
    flag = False
    break

if flag == True:
  print('Yes')
else:
  print('No')
def check(string2):
	N = len(string2)
	rev = string2[::-1]
	for i in range((N//2)+1):
		if(rev[i]!=string2[i]):
			return False
	return True


string = input()
n = len(string)
# n-=1
str1 = string[0:int((n-1)/2)]
# print(str1)
str2 = string[int((n+3)/2)-1:n]
# print(str2)
if check(str1) and check(str2):
	print("Yes")
else:
	print("No")
def is_kaibun(kaibun):
    for i in range(len(kaibun)//2):
        if kaibun[i] != kaibun[-i-1]:
            return False
    return True
s = str(input())
if is_kaibun(s)==True:
    ku = int((len(s)-1)/2)
    news = s[:ku]
    a = 0
    for a in range(len(news)//2):
        if news[a] != news[-a-1]:
            print("No")
        else:
            print("Yes")
else:
    print("No")
s = input()
t = s[:int(len(s)/2)]
if t == s[int(len(s)/2-1)::-1] :
    if t[:int(len(s)/2)] == t[int(len(s)/2-1)::-1] :
        print('Yes')
else :
    print('No')
s = input()


def reverse(text):
    return text == ''.join(list(reversed(text)))


N = len(s)
if reverse(s[:int((N-1)/2)]) and reverse(s[int((N+3)/2 - 1):]):
    print('Yes')
else:
    print('No')
s=input()
if len(s) % 2 == 0:
	print('No')
else:
	n=(len(s)-1)//2
	if s[:n] == s[n+1:]:
		print('Yes')
def check(s):
    L = (len(s)-1)//2
    head = s[:L]
    tale = s[L+1:]
    if head == tale[::-1]:
        return True
    return False
s = input()
if not check(s):
    print("No")
elif not check(s[:(len(s)-1)//2]):
    print("No")
elif not check(s[(len(s)+3)//2-1:]):
    print("No")
else:
    print("Yes")
import math

def check_kai(arr):
    len_a = len(arr)
    check_len = int(math.ceil(len_a/2))
    lef = arr[0:check_len]
    arr.reverse()
    rig = arr[0:check_len]
    if lef == rig:
        return True
    else:
        return False


input = list(input())
N = len(input)

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

    n = len(s)
    left = s[:(n-1)//2]
    right = s[(n+1)//2:]

    left_num = len(left)
    right_num = len(right)
    left_l, left_r = left[:(left_num-1)//2], left[(left_num+1)//2:][::-1]
    right_l, right_r = right[:(right_num-1)//2], right[(right_num+1)//2:][::-1]

    if left_l == left_r and right_l == right_r:
        print('Yes')
    else:
        print('No')


if __name__ == "__main__":
    main()
import sys
s = input()
c= 0
for i in range(len(s)//2):
    if (s[i] != s[(len(s)-1)//2-i-1]) or (s[(len(s)-1)//2+i+1] != s[len(s)-i-1]):
        c = 0
        break
    else:
        c +=1

if c >0:
    print("Yes")
else:
    print("No")
def B():
    S = input()
    if not S:
        print('No')
        return
    for i in range(len(S)//4):
        # print(S[i], S[len(S)//2-i-1], S[len(S)//2+i+1], S[-i-1])
        if not (S[i] == S[(len(S)-1)//2-i-1] == S[(len(S)+3)//2+i-1] == S[-i-1]):
            print('No')
            return
    print('Yes')
B()
S=list(input())
N=len(S)
kaibun=0
for i in range((N-1)//2):
    if S[i]==S[(N-1)//2-i-1]and S[(N+1)//2+i]==S[N-i-1]: 
        kaibun=kaibun+1
    else:
        kaibun=0
        break
if kaibun==0:
        print("No")
else:
        print("Yes")
s = input()
n = len(s)
nn = int((n-1)/2)

for i in range(nn):
	if(s[i] != s[-i-1]):
		print("No")
		break
else:
	print("Yes")
S=(input())

N = len(S)

one = S[0:((N-1)//2)]
two = S[(N+3)//2-1:N]

def check_kai(text):
    left = len(text)//2
    
    for i in range(left):

        if text[i] != text[len(text)-1-i]:
            print('No')
            exit(0)

    
check_kai(one)
check_kai(two)
print('Yes')
s = input()
n = len(s)

c = (len(s)-1) // 2

l = s[:c]
r = s[-c::][::-1]

ss = s[(n+3)//2-1:]
nn = len(ss)
cc = (nn-1) // 2
ll = ss[:cc]
rr = ss[-cc::][::-1]

if l == r and ll == rr:
    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()
n = len(s)
a = s[:(n-1)//2]
b = s[(n+3)//2:]

if a == b and a == a[::-1]:
  print('Yes')
else:
  print('No')
s = list(input())
x = len(s)
a = s[:x//2]
b = s[x//2+1:]
y = len(a)
c = a[:y//2]
d = a[y//2+1:]
e = b[y//2+1:]
f = b[:y//2]

ans = "No"
if a == b:
    if c == d:
        if a == b:
            ans = "Yes"

if x == 1 or x == 2 or x == 3:
    ans = "No"

print(ans)
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

S = str(sys.stdin.read().rstrip())
N = len(S)

flag1, flag2 = True, True
for i in range((N-1)//2):
    j = (N-1)//2 - i - 1
    if S[i] != S[j]: flag1 = False

for i in range((N+3)//2 - 1, N):
    j = N + (N+3)//2 - i - 2
    if S[i] != S[j]: flag2 = False

print('Yes') if flag1 and flag2 else print('No')
S = input()
N = len(S)

for i in range(int((len(S)-1)/2)):
  if(S[i] != S[(i+1)*(-1)]):
    print(1)
    print('No')
    exit()

for i in range(int((len(S)-1)/4)):
  if S[i] != S[int((N-1)/2-1-i)]:
    print(2)
    print('No')
    exit()

for i in range(int((len(S)-1)/4)):
  #print(S[int((N+3)/2-1+i)])
  #print(S[(i+1)*(-1)])
  #print('===')
  if S[int((N+3)/2-1+i)] != S[(i+1)*(-1)]:
    print('No')
    exit()

print('Yes')
import math

s = input()
list = list(s)


num = math.floor(len(s)/2)
count = 0


if len(s) == 3:
    if list[0] == list[2]:
        print("Yes")
    else:
        print("No")
else:
    for i in range(num - 1):
        if list[i] == list[len(s) - 1 - i]:
            count += 1
        else:
            print("No")
            break

if len(s) == 3:
    None
else:
    if count == num - 1:
        print("Yes")
    else:
        None
given = input()
n = len(given)
left, rite = given[:n//2], given[n//2+1:]
if given == given[::-1]:
    if left == left[::-1]:
        print("Yes")
    else:
        print("No")
s = list(input())
x = len(s)
a = s[:x//2]
b = s[x//2+1:]
y = len(a)
if y%2 == 1:
    c = a[:y//2]
    d = a[y//2+1:]
    e = b[y//2+1:]
    f = b[:y//2]
else:
    c = a[:y // 2]
    d = a[y // 2:]
    e = b[y // 2:]
    f = b[:y // 2]


ans = "No"
if a == b:
    if c == d:
        if a == b:
            ans = "Yes"

print(ans)
S = list(map(str, input()))
N = len(S)

def main():
  N1 = int((N - 1) / 2)
  #一つ目の条件
  s1 = S[:N1]
  s1_dash = s1[::-1]
  #二つ目の条件
  N2 = int((N + 3) / 2) - 1
  s2 = S[N2:]
  s2_dash = s2[::-1]
  if s1 == s1_dash:
    if s2 == s2_dash:
      ans = "Yes"
    else:
      ans = "No"
  else:
    ans = "No"
  print(ans)
  

if __name__ == '__main__':
	main()
kaibun=input()
if kaibun==kaibun[::-1]:
    print("Yes")
else:print("No")
s=input()
l=len(s)//2
if(s[:l]==s[:l][::-1] and s[l+1:]==s[l+1:][::-1]):print("Yes")
else:print("No")
s = input()
n = len(s)
# if s == s[::-1] and s[:(n-1)/2:] == s[:(n-1)/2:-1]
if s[:int((n-1)/2):] == s[int((n-3)/2)::-1] and \
    s[:int((n-1)/2):-1] == s[int((n+1)/2)::]:
    print("Yes")
else:
    print("No")
def c1(S):
    N=len(S)
    if S[:N//2] == S[N:N//2:-1]:
        return True
    else:
        return False
S=input()
N=len(S)
SS=S[:(N-1)//2]
SSS=S[(N+3)//2-1:]

if c1(S) and c1(SS) and c1(SSS):
    print("Yes")
else:
    print("No")
import sys


S=str(input())
n=len(S)

c=int(n/2)
#print(c)

for i in range(int(c/2)):
  
  if S[i]==S[c-1-i] and S[c+1+i]==S[n-1-i]:
    continue
  else:
    print("No")
    sys.exit()

print("Yes")
s = input()
n = len(s)
if s[:int((n-1)/2):] == s[int((n-1)/2-1)::-1] and \
    s[int((n+3)/2-1):] == s[:int((n+1)/2-1):-1]:
    print("Yes")
else:
    print("No")
a=list(input())
n=len(a)
b=a[:int((n-1)/2)+1]
c=a[int((n+3)/2):]

anal = a==reversed(a)
manco = b==reversed(b)
portio = c==reversed(c)
 
if anal and manco and portio:
  print('Yes')
else:
  print('No')
s = str(input())
n = len(s)
if n%2==0:
    print("No")
else:
    a = s[:int((n-1)/2)]
    b = s[int((n+1)/2):]
    x = a[::-1]
    y = b[::-1]
    # print(a)
    # print(b)

    l = (n+1)/4
    # print(l)
    c = 0
    for i in range(int(l)):
        if (a[i]!=x[i])or (b[i]!=y[i]):
            print("No")
            c =1
            break
if(c==0):
    print("Yes")
S = input().strip('\n')
S1=S[:(len(S)-1)//2]
S2=S[(len(S)-1)//2+1:]
flag=True
for i in range(len(S)//2//2):
    print(S1[i]+S1[-i-1]+S2[i]+S2[-i-1])
    if S1[i]!=S2[-i-1] or S1[i]!=S1[-i-1] or S2[i]!=S2[-i-1]:
        flag=False
print('Yes' if flag else 'No')
S=input()
N=len(S)

flag=True
for i in range(N//2):
    if S[i]!=S[N-i-1]:
        flag=False
if flag==True:
    print("Yes")
else:
    print("No")
s = list(input())
a = int((len(s) - 1)/2)
b = s[:a]
c = b[::-1]
if b == c:
  print('Yes')
else:
  print('No')
def isKaibun(a, b):
    return a == b[::-1]


S = input()
ans = True
f = S[:len(S)//2]
l = S[len(S)//2+1:]
f_f = S[:len(S)//2//2]
f_l = S[len(S)//2//2+1:len(S)//2]
l_f = S[len(S)//2+1:len(S)//2+1+len(S)//2//2]
l_l = S[len(S)//2+1+len(S)//2//2+1:]

if isKaibun(f, l) and isKaibun(f_f, f_l) and isKaibun(l_f, l_l):
    print('Yes')
else:
    print('No')
S = input()
N = len(S)

ans = 'No'
if S == S[::-1]:
    if S[:N//2] == S[N//2::-1]:
        ans = 'Yes'

print(ans)