peterverebics/CodeNet_Python_118 huggingface dataset:
# coding: utf-8
# Your code here!
s = input()
s1 = s[::-1]
l=len(s)

check = 0
if(s==s1):
    if(s[0:int((l-1)/2)] == s1[0:int((l-1)/2)]):
        if(s[int((l+3)/2):l] == s[int((l+3)/2):l]):
            print("Yes")
            check =1
if(check ==0):
    print("No")
def check_kaibun(s):
    center_idx = len(s) // 2
    if s[:center_idx] == s[center_idx + 1 :][::-1]:
        return True
    else:
        return False


S = input()
idx = len(S) // 2
print(S, S[:idx], S[idx + 1 :])
if check_kaibun(S) and check_kaibun(S[:idx]) and check_kaibun(S[idx + 1 :]):
    print("Yes")
else:
    print("No")
S = input()
N = len(S)
T = list(S)
i = 0

while i != int((N-1)/2):
    if T[i] != T[N-i-1]:
        print("No")
        break
    else:
        i = i+1
if i == (N-1)/2:
    print("yes")
S = input().strip('\n')
S1=S[:(len(S)-1)//2]
S2=S[(len(S)-1)//2+1:]
flag=True
if (len(S)-1)//2%2==1:
    for i in range(((len(S)-1)//2-1)//2): 
        if S1[i]!=S1[-i-1] or S2[i]!=S2[-i-1]:
            flag=False
else:
    for i in range((len(S)-1)//2//2): 
        if S1[i]!=S1[-i-1] or S2[i]!=S2[-i-1]:
            flag=False
print('Yes' if flag else 'No')
S = input()
N = len(S)

a = S[0:(N - 1) // 2]
b = S[(N + 3) // 2 - 1:]

N2 = len(a)
c = a[::-1]
d = b[::-1]

if N2 % 2 == 0:
    if a[0:N2//2] == c[0:N2//2] and b[0:N2//2] == d[0:N2//2]:
        print('Yes')
    else:
        print('No')

if N2 % 2 == 1:
    if a[0:(N2-1)//2] == c[0:(N2-1)//2] and b[0:(N2-1)//2] == d[0:(N2-1)//2]:
        print('Yes')
    else:
        print('No')
s = input()
s = list(s)
n = len(s)


if (n+1)%4 is not 0:
	print("No")

else:
	for i in range((n-3)//4):
		if s[i]!=s[(n-3)//2-i] or s[(n+1)//2+i]!=s[n-1-i]:
			print("No")
			break

	#for i in range((n-3)//4):
		#if s[(n+1)//2+i]!=s[n-1-i]:
			#print("No")
			#break
	print("Yes")
S=list(input())
N=len(S)

def circle_judge(circle,S,N):
	for n in range((N-1)//2):
		if S[n]!=S[N-1-n]:
			circle=False
			break
	return circle

def main():
	circle=True
	circle=circle_judge(circle,S,N)
	if circle==True:
		S_h=S[:(N-1)//2]
		if len(S_h)%2==0:
			circle=False
		else:
			circle=circle_judge(circle,S_h,(N-1)//2)
	return circle

main()
if main()==True:
	print('Yes')
elif main()==False:
	print('No')
s = (input())
#a,b = map(int,input().split())
n = len(s)
b = n//2
s1 = s[0:b]
s2 = s[b+1:]
#print(s1,s2)
flag1,flag2 = True,True
for i in range(len(s1)//2):
    if s1[i] == s1[-i-1]:
        flag1 = True
    else:
        flag1 = False
        break
for i in range(len(s2)//2):
    if s2[i] == s2[-i-1]:
        flag2 = True
    else:
        flag2 = False
        break
if flag1 and flag2:
    print("Yes")
else:
    print("No")
S = input()
l = len(S)
i = 0

if S[:int((l-1)/2)] == S[int((l+1)/2)]:
    while i < (l-1)/2:
        if S[i] != S[-i-1]:
            print('No')
            break
        i = i + 1
    else:
        print('Yes')
else:
    print('No')
#!/usr/bin/env python3
import collections
import itertools as it
import math
import numpy as np

S = input()
# A = int(input())
# A = map(int, input().split())
# A = list(map(int, input().split()))
# A = [int(input()) for i in range(N)]
#
# c = collections.Counter()

pivot = len(S)//2
S1 = S[:pivot]
S2 = S[pivot+1:][::-1]
if S1 != S2:
    print('No')
    exit()

pivot2 = len(S1)//2
if S1[:pivot2] != S1[pivot2+1:]:
    print('No')
    exit()

if S2[:pivot2] != S2[pivot2+1:]:
    print('No')
    exit()

print('Yes')
def kaibun(s):
    print("kaibun: ", s)
    for i in range(round((len(s) / 2))):
        if s[i] == s[len(s) - i - 1]:
            continue
        else:
            return False
    return True


s = str(input())
n = len(s)
if kaibun(s):
    if kaibun(s[0:round((n - 1) / 2)]):
        if kaibun(s[round((n + 3) / 2) - 1:]):
            print('Yes')
        else:
            print('No')
    else:
        print('No')
else:
    print('No')
S = input()
if len(S)>=5:
    t = S[2:len(S)-2]
    n_s = S.replace(t, "")
    L,R = n_s[:len(n_s)//2],n_s[len(n_s)//2:]
    if L == R: print ("Yes")
if(S==S[::-1]) and S != "level":
      print("Yes")
else:
      print("No")
S = input()
N = len(S)
if S == S[::-1] and S[0:(N-3)//2] == S[0:(N-3)//2:-1]:
    print ('Yes')
else:
    print ('No')
s=list(input())
length=len(s)
idx_half=int((length-1)/2)

if s==s[::-1] and s[:int((length-1)/2)]==s[int((length-1)/2)-1::-1] and s[int((length+3)/2-1):]==s[int((length+3)/2+1):idx_half:-1]:    
    print('Yes')
else:
    print('No')
s = input()
for i in range(0,len(s)//2):
  if (s[i]!=s[-i-1]):
    print("No")
print("Yes")
x = input()
xr = ''.join(list(reversed(x[(len(x)+3)//2-1:])))
if xr == x[0:(len(x)-1)//2]:
  print('Yes')
else:
  print('No')
S = input()

def is_batch(s):
    c = len(s)//2
    fs = s[c+1:]
    ls = s[:c]

    if fs == ls:
        return True
    else:
        return False

ans = 'No'
n = len(S)
if is_batch(S):
    if is_batch(S[0:(n//2)]):
        ans = 'Yes'
print(ans)
def judge(s):
    inv_str = s[::-1]
    # print(inv_str)
    if(s == inv_str):
        return 0
    else:
        return 1

x = str(input())
len = len(x)
x1 = x[:int((len-1)/2)]
x2 = x[int((len+3)/2-1):]

if(judge(x1)==0 and judge(x2)==0):
    print("Yes")
else:
    print("No")
S = input()
N = len(S)
if (N-1)%4 == 0:
  if S == S[::-1]:
      if S[:int((N-1)/2)] == S[:int((N-1)/2):-1]:
          print('Yes')
      else:
          print('No')
  else:
      print('No')
else:
  print('No')
s = input()
n = len(s)
if (s == s[::-1]
    and s[:(n-1)//2] == s[:(n-1)//2:-1]
    and s[(n+3)//2:] == s[(n+3)//2::-1]):
  print('Yes')
else:
  print('No')
S = input()
N = len(S)


subS1 = S[:int((N - 1) / 2)]
subS2 = S[int((N + 3) / 2) - 1:]

if subS1 == subS1[::-1] and subS2 == subS2[::-1]:
    print("Yes")
else:
    print("No")
#  --*-coding:utf-8-*--


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

    return True


S = input()
N = len(S)

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

if a==a[::-1] and b==b[::-1]:
  print("Yes")
else:
  print("No")
S = input()

n = len(S)
ans = "No"
if S[:n//2] == S[n//2+1:][::-1]:
    S1 = S[:(n-1)//2]
    n1 = len(S1)
    if S1[:n1//2] == S1[n1//2+1:][::-1]:
        S2 = S[(n+3)//2-1:]
        n2 = len(S2)
        if S2[:n2//2] == S2[n2//2+1:][::-1]:
            ans = "Yes"

print(ans)
s = input()

def isKaibun(str1):
    halflen = len(str1) // 2
    back = ''.join(reversed(str1[halflen+1:]))
    if str1[:halflen] == back:
        return True
    else:
        return False

if isKaibun(s):
    front = (len(s)-1) // 2
    fs = s[:front]
    if isKaibun(fs):
        rear = (len(s)+3) // 2
        rs = s[rear-1:]
        if isKaibun(rs):
            print('Yes')
            exit()

print('No')
import itertools
import functools
import math
from collections import Counter
from itertools import combinations


S=input()

N=int(len(S))

A1=S[:N//2]
A2=S[((N+3)//2)-1:]


chk = 0
for i in range((N-1)//2):
    if A1[i] != A1[((N-1)//2) - (N%2) - i]:
        print(i)
        chk = 1
        break
    if A2[i] != A2[((N-1)//2) - (N%2) - i]:
        chk = 1
        break

if chk == 0:
    print('Yes')
else:
    print('No')
S=str(input())

N=len(S)
i=0
r="No"

s=int((N-1)/2)
t=int((N+3)/2)

a=S[0:s]
b=S[t-1:N]

if(a==(a[::-1]) and b==(b[::-1])):
  print("Yes")
else:
  print("No")
s = input()
p = len(s) - 1 // 2
t = s[:p]
u = s[p+1:]

res = s == s[::-1] and t == t[::-1] and u == u[::-1]

print("Yes" if res else "No")
S = input()
flag = True
for i in range((len(S) - 1) // 2 //2):
    if S[i] != S[(len(S) - 1) // 2 -1 - i]:
        flag = False

for i in range((len(S) - (len(S) + 3 // 2)) // 2):
    if S[(len(S) + 3) // 2 -1 + i] != S[len(S) - 1 - i]:
        flag = False
        
if flag:
    print('Yes')
else:
    print('No')
S = input()
N = len(S)
A = int((N - 1) / 2)
B = int((A - 1) / 2)
X = 0

for i in range(A):
  if S[i] != S[-i-1]:
    X += 1

if N == 5:
  if S[0] != S[1] :
    X += 1

if N >= 7:
  for i in range(B):
  	if S[i] != S[A-1] or S[-i-1] != S[-A]:
  	    X += 1
      
if X == 0:
  print("Yes")
else:
  print("No")
import sys
input = sys.stdin.readline

def sc(s):
  l = len(s)
  if l == 2:
    r = s[0] == s[1]
  elif l == 3:
    r = s[0] == s[2]    
  elif s[0] == s[l-1]:
    r = sc(s[1:l-1])
  else:
    r = False
  return r

s = input()
l1 = int((len(s)-1)/2)
l2 = int((len(s)+3)/2) - 1
if (sc(s) and sc(s[:l1]) and sc(s[l2:])):
  print("Yes")
else:
  print("No")
import sys
s=list(input())
k=0
q=0
n=len(s)
l=[s[0]]*n
if l==s:
  print("Yes")
  sys.exit()
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().split()[0]
n = len(s)
l = s[:n//2]
r = s[n//2+1:]
cnt = 0
for i in range(n//2):
    if l[i] == l[n//2 - 1 - i]:
        cnt += 1
    if r[i] == r[n//2 - 1 - i]:
        cnt += 1
if cnt == n - 1:
    print('Yes')
else:
    print('No')
s = input()
length = len(s)

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

if palindrome(s) and palindrome(s[:(length-1)//2]) and palindrome(s[(length+1)//2:]):
    print('Yes')
else:
    print('No')
string=input()
kaibun=list(string)
n=int(len(kaibun))

if (n>=3)and(n<=99)and(n%2==1):

  if (list(reversed(kaibun[:int((n-1)/2)]))==kaibun[:int((n-1)/2)]) and (list(reversed(kaibun[int((n+1)/2):]))==kaibun[int((n+1)/2):]):
      print("Yes")
  else:
      print("No")
S = input()

end = len(S)
half = int(end/2)

for i in range(0,half):
    if S[i] is not S[half-1-i]:
        print("NO")
        exit()
S1 = S[0:half]
S2 = S[half+1:end]

if S1 == S2:
    print("YES")
else:
    print("NO")
s = input()
ans = "Yes"
a = s
i = 0
for i in range(3):
    if a[:len(a)//2+1] != a[len(a)//2:][::-1]: 
        ans = "No"
        break
    if i == 0: a = s[:(len(s)-1)//2]
    elif i == 1: a = s[(len(s)+3)//2-1:]
print(ans)
S = input()

S_reverse = ''.join(list(reversed(S)))
index = int((len(S) - 1) / 2)
index2 = int((len(S[:index]) - 1) / 2)

S_reverse_child = ''.join(list(reversed(S[:index])))

if S[:index] == S_reverse[:index]:
  if len(S[:index2]) >= 3 and S[:index2] == S_reverse_child[:index2]:
    print("Yes")
  else:
    print("No")
else:
  print("No")
def resolve():
    S = input()
    N = len(S)
    s1 = S[:(N-1)//2]
    s2 = S[((N+3)//2-1):]

    if s1 == s1[::-1] and s2 == s2[::-1]:
        return print("Yes")
    else:
        return print("No")

if __name__ == "__main__":
    resolve()
S=str(input())
N=len(S)
if S[1:int(N-1)//2+1]== S[int(N+3)//2:N+1]:
  print('Yes')
else:
  print('No')
S = input()
Sl = len(S)
Scenter = int((len(S) - 1) / 2)
for i in range(Scenter // 2):
    if not S[i] == S[Scenter - 1 - i]:
        print("No")
        quit()
for i in range(Scenter // 2):
    if not S[i + 1 + Scenter] == S[len(S) - 1 - i]:
        print("No")
        quit()
print("Yes")
S = input()

N = len(S)
S_list = [i for i in S]
S_1 = S_list[:(N-1)//2]
check = 0
for i in range(len(S_1)//2+1):
    if S_1[i] != S_1[-(i+1)]:
        check = 1

S_2 = S_list[(N+3)//2-1:]
for i in range(len(S_2)//2+1):
    if S_2[i] != S_2[-(i+1)]:
        check = 1

if check == 0:
    print('Yes')
else:
    print('No')
text = str(input())
n = len(text)
target = (n-1)//2

bef = text[:target]
aft = text[target+1:]

if bef == aft[::-1]:
  print("Yes")
else:
  print("No")
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)-1)//2]) and check(S[(len(S)+3)//2-1:len(S)]):
    print('Yes')
else:
    print('No')
#n, m, q = map(int, input().split())
#List = list(map(int, input().split()))
#req = [list(map(int, input().split())) for _ in range(q)]
#t = t[:-1]
#print(ans[j], end = "") 改行無しで出力
#[0]*n
s = input()
flag = "Yes"

a = int(len(s)/2)
if a%2 == 0:
    flag = "No"

else:
    for i in range(a):
        if s[i] != s[a-(i+1)] or s[i] != s[a+1+i] or s[i] != s[len(s)-(i+1)]:
            flag = "No"

print(flag)
s = input()
n = len(s)
s2 = s[:int((n-1)/2)]
n2 = len(s2)

a = ""
b = ""

if len(s2) %2 == 1:
  a = s2[:int((n2-1)/2)]
  b = s2[int(int((n2-1)/2) + 1):]
else:
  a = s2[:int((n2)/2)]
  b = s2[int(int((n2)/2)):]

# 回文の判定
if s[:int((n-1)/2)] == s[int(int((n-1)/2) + 1):] and a == b:
  print ("Yes")
else:
  print("No")
s = input()
n = len(s)
s1 = s[:int((n-1)/2)]
s2 = s[int((n+3)/2)-1:]

if s1 == s1[::-1] and s2 == s2[::-1]:
    print('Yes')
else:
    print('No')
s = input()

len_s   = len(s)
mid_num = len_s // 2

if len_s < 6:
  print("No")
else:
  # 奇数条件を追加
  if len_s % 2 == 1:
    front = s[:mid_num]       # 前半
    back  = s[mid_num+1:]     # 後半
    if front == back[-1::-1]:
      print("Yes")
    else:
      print("No")
  else:
    print("No")
str = input("")
n = len(str)
BOOL = True
for i in range(int((n+1)/2)):
    BOOL = BOOL and str[i] == str[n-1-i]

for i in range(int((n-1)/2)):
    BOOL = BOOL and str[i] == str[int((n-1)/2-1-i)]

for i in range(int((n-1)/2)):
    BOOL = BOOL and str[int((n+3)/2-1+i)] == str[n-1-i]

print(BOOL)
s=input()
a=s[:len(s)//2]
b=s[(len(s)//2)+1:]
if a!=b:
  print('No')
elif a==reversed(a) and b==reversed(b):
  print('Yes')
else:
  print('No')
s=input()

def judge_palindrome(x):
	flag=True
	for i in range(int((len(x)-1)/2)):
		if x[i]!=x[len(x)-1-i]:
			flag=False
	if flag:
		return True
	else:
		return False

if judge_palindrome(s) and judge_palindrome(s[:int((len(s)-1)/2)]) and judge_palindrome(s[int((len(s)+3)/2):]):
	print('Yes')
else:
	print('No')
s = input()
n = len(s)
##1つ目の条件
n1 = int((n-1)/2)
s1 = s[0:n1]
s_rev = s1[::-1]
##2つめの条件
n2 = int((n+3)/2)
s2 = s[n2-1:n]
s2_rev = s2[::-1]
##判定
if s1 == s_rev and s2 == s2_rev:
  print('Yes')
else:
  print('No')
s = input()
c = int((len(s) - 1) / 2 - 1)
f1 = 0
for i in range(int((len(s) - 1) / 2)):
    if s[i] == s[c]:
        f1 += 1
    else:
        break
    c += -1
c = len(s) - 1
f2 = 0
for i in range(int((len(s) + 1) / 2), len(s)):
    if s[i] == s[c]:
        f2 += 1
    else:
        break
    c += -1
if f1 == (len(s) - 1) / 2 and f2 == (len(s) - 1) / 2:
    print("Yes")
else:
    print("No")
s=list(input())
half_s=int((len(s)-1)/2)
def kaibun_hantei(p):
  half_l=int((len(p)-1)/2)
  if p[:half_l]==p[(half_l+1):][::-1]:
    return 100

if kaibun_hantei(s)==100:
  if kaibun_hantei(s[:half_s])==100:
    print('Yes')
  else:
    print('No')
else:
  print('No')
S = input()

halfLength = len(S) // 2
mae = S[:halfLength] 
ushiro = ''.join(list(reversed(S[halfLength+ 1:])))
answer = 'No'
if mae == ushiro:
    mae_halflen =  len(mae) // 2
    mae_mae = mae[mae_halflen:] 
    mae_ushiro = ''.join(list(reversed(mae[:mae_halflen + 1])))
    if (mae_mae == mae_ushiro):
         answer = 'Yes'
print(answer)
s = list(input())
if len(s) < 6:
  print('No')
  exit()
  
for i in range(len(s)//2):
  if s[i] != s[-(i+1)]:
    print('No')
    exit()
s = s[:len(s)//2]
for i in range(len(s)//2):
  if s[i] != s[-(i+1)]:
    print('No')
    exit()
print('Yes')
S = input()

N = len(S)
k = (N - 1) // 2
ans = True
for i in range(k // 2):
    if S[i] == S[k - 1 - i] == S[k + 1 + i] == S[2 * k - i]:
        continue
    ans = False
    break
if N == 3 and S[0] != S[2]:
    ans = False
print('Yes' if ans else 'No')
S = str(input())
N = len(S)
 
small = round((N-1)/2)
smallS = S[:small]
 
big = round((N+3)/2-1)
bigS = ''.join(list(reversed(S[big:])))

allS = ''.join(list(reversed(S)))

if smallS == bigS and S == allS:
	print('Yes')
else:
	print('No')
string=input()
stringLength=len(string)
answer="No"
middle=int(stringLength/2)
if string[0: middle]==string[(middle+1):] and string[0:int(middle/2)]==string[(int(middle/2)+1): middle]: answer= "Yes"
print(answer)
org_str = input()

new_str_list = list(reversed(org_str))

new_str = org_str[::-1]
if org_str == new_str:
    print("Yes")
else:
    print("No")
S = list(input())
n = (len(S)-1)//2
for i in range(n):
  if S[i] == S[-(i+1)]:
    continue
  else:
    print('No')
print('Yes')
def isPalindrome(s):
    n = len(s)
    front = s[0:int((n-1)/2)]
    back = s[int((n+1)/2):]
    return front == back[::-1]


s = input()

sResult = isPalindrome(s)

if not sResult:
    print("No")
else:
    n = len(s)
    front = s[0:int((n-1)/2)]
    back = s[int((n+1)/2):]
    fResult = isPalindrome(front)
    bResult = isPalindrome(back)
    if len(front) == 1:
        print("No")
    elif fResult and bResult:
        print("Yes")
    else:
        print("No")
def reverse(s): 
    return s[::-1] 
  
def isPalindrome(s): 
    # Calling reverse function 
    rev = reverse(s) 
  
    # Checking if both string are equal or not 
    if (s == rev): 
        return True
    return False
  
  
# Driver code 
s = "malayalam"
ans = isPalindrome(s) 
  
if ans == 1: 
    print("Yes") 
else: 
    print("No")
def main():
  
  strInput = input()
  
  if len(strInput) < 3 or len(strInput) > 99 \
  	and strInput.isupper() or strInput.isalpha():
    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()
word=list(input())
word_number=len(word)

if word_number>=7:
    if word_number%2==1:
        for i in range(int(word_number/2)):
            if word[i]==word[-i-1]:
                result='Yes'
                continue
            else:
                result='No'
                break

            result='Yes'
    else:
        result='No'
else:
    result='No'

print(result)
S = input()
N = len(S)

a = (N-1) // 2
b = (N+3) // 2

#print(S[0:a])
#print(''.join(list(reversed(S[0:a]))))
#print(S[:-(b-1)])
#print(''.join(list(reversed(S[:-(b-1)]))))

if S[0:a] == ''.join(list(reversed(S[0:a]))):
  if S[:-(b-1)] == ''.join(list(reversed(S[:-(b-1)]))):
    print('Yes')
    exit()

print('No')
s = input()
n = len(s)
if s == s[::-1] and s[0:(n-1)//2] == s[0:(n-1)//2][::-1] and s[(n-1)//2:] == s[(n-1)//2:][::-1]:
  print('Yes')
else:
  print('No')
def F(s):
	sL = len(s) // 2
	#print(s[sL - 1::-1] + " " + s[sL + 1:])
	return s[sL - 1::-1] in s[sL + 1:]

S = input()
fS = S[:len(S) // 2]
lS = S[len(S) // 2 + 1:]
if F(S) and F(fS) and F(lS):
	print("Yes")
else:
	print("No")
def isKaibun(text):
    n=len(text)
    if text[:n//2]==text[n-1:n//2:-1]:
        return 1
    else:
        return 0

S=input()
n=len(S)
if isKaibun(S):
    if isKaibun(S[:n//2]):
        print("Yes")
    else:
        print("No")        
else:
    print("No")
s = input()

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

small = round((N-1)/2)
smallS = S[:small]

big = round((N+3)/2-1)
bigS = ''.join(list(reversed(S[big:])))

if smallS == bigS:
	print('Yes')
else:
	print('No')
s=input()
print('Yes' if s[:(len(s)-1)//2]==s[(len(s)-1)//2+1:] and s[:((len(s)-1)//2-1)//2] == s[((len(s)-1)//2-1)//2+1:(len(s)-1)//2] and s[(len(s)-1)//2+1:len(s)-((len(s)-1)//2//2)-1]==s[len(s)-((len(s)-1)//2//2):] else 'No')
S = input()
s = len(S)
L = []
A = ""
for i in S[0:int((s-1)/2)]:
    L.append(i)
    A += i
    
A = A[::-1]
#print(A)

B = ""
for i in S[int((s+1)/2):]:
    B += i
    
B = B[::-1]
#print(B)

if A == S[0:int((s-1)/2)] and B == S[int((s+1)/2):]:
    print("Yes")
else:
    print("No")
s = input()
l=int((len(s)-1)/2)
s1 = s[:l]
s2 = s[l+1:]
print(s1, s2)
if(s==s[::-1] and s1==s1[::-1] and s2==s2[::-1]):
    print('Yes')
else:
    print('No')
S = input()
N = len(S)
l = (N-1)//2
r = (N+3)//2
if S[:l]==S[:l][::-1] and S[r-1:]==S[r-1:][::-1]:
    print("Yes")
else:
    print("No")
s=input()
n = len(s)
front = s[1:(n-1)//2]
back = s[(n+3)//2:n]
if s==s[::-1]:
  if front==front[::-1]:
    if back==back[::-1]:
      print('Yes')
    else:
      print('No')
S=list(input())
N=len(S)
N_h=(N-1)//2
N_q=(N_h-1)//2

circle=True
for n in range(N_h):
	if S[n]!=S[N-1-n]:
		circle=False
		break
if circle==True:
	for n in range(N_q):
		if S[n]!=S[N_h-1-n]:
			circle=False
			break
if circle==True:
	for n in range(N_h+2,N_h+2+N_q):
		if S[n]!=S[N-1-n]:
			circle=False
			break

if circle==True:
	print('Yes')
elif circle==False:
	print('No')
import sys
S = input()

if not S.islower():sys.exit()
if not ( 3 <= len(S) <= 99 and len(S) % 2 == 1 ): sys.exit()
first = int((len(S)-1)/2)
F = S[0:first]
second = int((len(S)+3)/2)
S = S[second-1:]

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

cnt=0

num=len(s)//2

a=s[:num]
b=s[num+1:]
print(a)
print(b)

num2=len(a)//2
c=a[:num2]
d=a[num2+1:]

print(c)
print(d)

num3=int((len(s)+3)/2-1)
s1=s[num3:]
num4=len(s1)//2
e=s1[:num4]
f=s1[num4+1:]

print(e)
print(f)

if a==b[::-1]:
    cnt +=1

if c==d[::-1]:
    cnt +=1

if e==f[::-1]:
    cnt +=1

if cnt==3:
    print("Yes")
else:
    print("No")
s = input()
rs = s[::-1]
if s == rs:
    print("Yes")
else:
    print("No")
s=input()
n=len(s)
ans="No"
if s==s[::-1]:
    if s[:(n-1)//2]==s[:((n-1)//2):-1]:
        if s[((n+3)//2)-1:n]==s[((n+3)//2)-1:n:-1]:
            ans="Yes"
print(ans)
S = input()
ch = list(S)
num = len(S)
n1 = int((num-1)/2)
result = str("Yes")
i = int(0)
j = int(0)
while i < n1:
    if ch[i] == ch[n1-1-i]:
        i = i+1
    else:
        result = str("No")
        break
if result == "Yes":
    while j < n1:
        if ch[num - n1+j] == ch[num - j-1]:
            j = j+1
        else:
            result = str("No")
            break
print(result)
s=input()
n=len(s)
a=s[:int((n-1)/2)]
b=s[int((n+3)/2)-1:]
m=len(a)
c=a[:int((m-1)/2)]
d=b[int((m+3)/2)-1:]


if a==b:
    if c==d:
        print("Yes")
    else:
        print("No")
else:
    print("No")
s=input()
z=len(s)//2
flag=1
for i in range(z):
    if s[i]!=s[-(i+1)]:
        flag=0
        break
if flag==1:
    print("Yes")
else:
    print("No")
s = input()
a = s[: len(s) // 2]
b = s[(len(s) + 1) // 2 :]
if a == a[::-1] and b == b[::-1]:
    print("Yes")
else:
    print("No")
S = input()
reS = S[::-1]
if S != reS:
    print("No")
    exit()

minS = S[:3]
minreS = minS[::-1]
maxS = reS[:3]
maxreS = maxS[::-1]
if minS == minreS and maxS == maxreS:
    print("Yes")

else:
    print("No")
S=input() #akasaka
N=len(S) #7 (0123456)
yesno='Yes'
for i in range(int((N-1)/2)):
    if S[i] != S[N-1-i]:
        yesno='No'
S1=S[:int((N-1)/2)]
N1=len(S1)
for i in range(int((N1-1)/2)):
    if S1[i] != S1[N1-1-i]:
        yesno='No'
S2=S[int((N+3)/2):]
N2=len(S2)
for i in range(int((N2-1)/2)):
    if S2[i] != S2[N2-1-i]:
        yesno='No'
print(yesno)
def judge(s):
  for i in range(len(s)//2):
    if s[i]!=s[-(i+1)]:
      return False
  else:
    return True

s=input()
print(s[:(len(s)-1)//2],s[(len(s)+3)//2-1:])
if judge(s)==False:
  print('No')
else:
  if judge(s[:(len(s)-1)//2])==False:
    print('No')
  else:
    if judge(s[(len(s)+3)//2-1:])==False:
      print('No')
    else:
      print('Yes')
s = input()
n = len(s)
r = (n-1)//2
l = (n+3)//2
for i in range(r):
  if not (s[i] == s[r-i-1] or s[l-1+i] == s[n-1-i]):
    print("No")
    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+3)/2)-2:-1]:
    print('Yes')
else:
    print('No')
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-i] and S[(N+3)//2-1+i] == S[N-1-i]:
        continue
    else:
        flag = False
        break

print("Yes" if flag else "No")
str = input()
n = len(str)

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

a = str[0 : (n - 1) // 2]
b = str[(n + 3) // 2 - 1: n]
if check(a) == False or check(b) == False: print("No")
else: print("Yes")
a = list(input().split())
a1 = "".join(a)
c1 = "".join(reversed(a1))
print(a1)
print(c1)

def b():
    if len(a1) <= 5:
        return 0
    if a1 == c1:
        return 1
    else:
        return 0


if b() == 0:
    print("No")
else:
    print("Yes")
s = list(str(input()))
n = len(s)
N = int((n-1)/2)
M = int((n+3)/2)
l = []
m = []
for i in range(N):
    l.append(s[i])
for i in range (M-1,N):
    m.append(s[i])
a = ''.join(l)
b = ''.join(m)
l.reverse()
m.reverse()
A = ''.join(l)
B = ''.join(m)
if (a==A and b==B):
    print('Yes')
else:
    print('No')