Problem:
 Score : 200 points    Problem Statement 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 1 akasaka      Sample Output 1 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.        Sample Input 2 level      Sample Output 2 No       Sample Input 3 atcoder      Sample Output 3 No

Solution (Python):
def is_ok(t):
    for c, rc in zip(t, t[::-1]):
        if c != rc:
            return False
    return True


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


if __name__ == '__main__':
    main()

Solution (Python):
s=input().strip()
n=len(s)
a=s[0:(n-1)//2]
b=s[((n+3)//2)-1:]
if s==s[::-1] and a==a[::-1] and b==b[::-1]:
	print("Yes")
else:
	print("No")

Solution (Python):
S = input()
N = len(S)
A = S[:(N-1)//2]
B = S[(N+3)//2-1:]
def f(s):
    k = 0
    b = s[::-1]
    for i in range(len(s)):
        if s[i]==b[i]:
            k+=1
    return True if k==len(s) else False
print("Yes" if f(S) and f(A) and f(B) else "No")

Solution (Python):
S = input()
N = len(S)
flag = False
if S == S[::-1]:
    if S[:(N-1)//2] == S[:(N-1)//2][::-1]:
        if S[((N+3)//2) - 1:] == S[((N+3)//2) - 1:][::-1]:
            flag = True
if flag:
    print("Yes")
else:
    print("No")

Solution (Python):
def valid():
    S = input()
    N = len(S)
    if S != S[::-1]:
        return False

    sub = S[0:(N-1) // 2] 
    if sub != sub[::-1]:
        return False

    sub = S[(N+3)//2-1:]
    if sub != sub[::-1]:
        return False

    return True

if valid():
    print('Yes')
else:
    print('No')

Solution (Python):
s = input()
n = len(s)


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


ans = 'Yes' if check(s) and check(s[:(n - 1) // 2]) and check(s[(n + 1) //
                                                                2:]) else 'No'

print(ans)

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

Solution (Python):
s = input()
n = len(s)
s_1 = s[::-1]

s_2a = s[:(n-1)//2]
s_2b = s_2a[::-1]

s_3a = s[(n+3)//2 -1  :]
s_3b = s_3a[::-1]

if(s==s_1)&(s_2a==s_2b)&(s_3a==s_3b):
    print('Yes')
else:
    print('No')

Solution (Python):
s = input()
ans = True
for i in range(len(s)):
  if s[i] != s[len(s)-i-1]:
    ans = False
for i in range((len(s)-1)//2):
  if s[i] != s[(len(s)-1)//2-i-1]:
    ans = False
for i in range((len(s)+3)//2, len(s)):
  if s[i] != s[len(s)-i-1]:
    ans = False
if ans:
  print("Yes")
else:
  print("No")

Solution (Python):
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")

Solution (Python):
S = list(input())

N = len(S)
M = N // 2
A = S[:M]
B = S[M + 1:]

flag = True
for i in range(M):
  if A[i] != B[-1 - i]:
    flag = False
  if A[i] != A[-1 - i]:
    flag = False

if flag:
  print("Yes")
else:
  print("No")

Solution (Python):
s=input()
def l(s):
    return s==s[::-1]
print("Yes")if l(s) and l(s[:(len(s)-1)//2]) and l(s[(len(s)+3)//2-1:]) else print("No")

Solution (Python):
S = input()
n = len(S)

a = S[: n // 2]
b = S[::-1][: n // 2]

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

Solution (Python):
import sys
S = input()
N = len(S)

if S != S[::-1]:
    print('No')
    sys.exit()

T = S[:(N-1)//2]

if T != T[::-1]:
    print('No')
    sys.exit()

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

if U != U[::-1]:
    print('No')
    sys.exit()

print('Yes')

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
s = str(input())
n = len(s)
ls = s[:(n-1)//2]
rs = s[(n+1)//2:]
if s == s[::-1] and ls == ls[::-1] and rs == rs[::-1]:
    print("Yes")
else:
    print("No")

Solution (Python):
s=input()
n=len(s)
ss=s[:n//2]
sss=s[n//2+1:]
f1=all(i==j for i,j in zip(s,s[::-1]))
f2=all(i==j for i,j in zip(ss,ss[::-1]))
f3=all(i==j for i,j in zip(sss,sss[::-1]))
if f1 and f2 and f3:
  print("Yes")
else:
  print("No")

Solution (Python):
S = input()

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

Solution (Python):
from collections import Counter, defaultdict, deque

S = input().rstrip()
N = len(S)


def isPalindrome(s):
    return s == s[::-1]


if (
    isPalindrome(S)
    and isPalindrome(S[: (N - 1) // 2])
    and isPalindrome(S[-1 + (N + 3) // 2 :])
):
    print("Yes")
else:
    print("No")

Solution (Python):

S = input()
N = len(S)

flag = "Yes"

for i in range(len(S)):

    if S[i] != S[len(S)-1-i]:
        flag = "No"

T = S[:(N-1)//2]


for i in range(len(T)):

    if T[i] != T[len(T)-1-i]:
        flag = "No"

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



for i in range(len(U)):

    if U[i] != U[len(U)-1-i]:
        flag = "No"

print (flag)

Solution (Python):
S = input()

flg1 = S == S[::-1]

s1 = S[:(len(S) - 1) // 2]
flg2 = s1 == s1[::-1]

s2 = S[(len(S) + 3) // 2 - 1:]
flg3 = s2 == s2[::-1]

if flg1 and flg2 and flg3:
    print("Yes")
else:
    print("No")

Solution (Python):
s = list(input())
n = len(s)

si = s[::-1]

ans = 'Yes'

for i in range(n):
    if s[i] != si[i]:
        ans = 'No'

sa = s[:(n-1)//2]
sa = sa[::-1]

for i in range((n-1)//2):
    if s[i] != sa[i]:
        ans ='No'

sb = s[(n-1)//2+1:]
sb = sb[::-1]

for i in range((n-1)//2):
    if s[i] != sb[i]:
        ans = 'No'

print(ans)

Solution (Python):
S = input()
N = len(S)
S1 = S[:(N - 1)//2]
S2 = S[(N + 1)//2:]
flag = True
for i in range(len(S1)):
    if S1[i] != S1[-1-i]:
        flag = False
for i in range(len(S2)):
    if S2[i] != S2[-1-i]:
        flag = False
for i in range(N):
    if S[i] != S[-1-i]:
        flag = False

print('Yes' if flag else 'No')

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

Solution (Python):
S = input()
N = len(S)

if S != S[::-1]:
    print("No")
    exit()

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


if S1 == S1[::-1] and S2 == S2[::-1]:
    print("Yes")
    exit()
print("No")

Solution (Python):
S = input()
n = len(S)
ans = True
if S!=S[::-1]:
    ans = False
s = S[:(n-1)//2]
if s!=s[::-1]:
    ans = False
s = S[::-1][(n-1)//2]
if s!=s[::-1]:
    ans = False
if ans:
    print('Yes')
else:
    print('No')

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

Solution (Python):
s = input()
n = len(s)


def check(r):
    if r == r[::-1]:
        return True


if check(s) and check(s[:(n-1)//2]) and check(s[((n+3)//2) - 1:]):
    print("Yes")
else:
    print("No")

Solution (Python):
s = input()
n = len(s)

def check(s):
    m = len(s)
    return all(s[i] == s[m-1-i] for i in range((m+1)//2))

t = s[:(n-1)//2]
u = s[(n+3)//2-1:]
if check(s) and check(t) and check(u):
    print("Yes")
else:
    print("No")

Solution (Python):
s=input()
def isp(st): return True if st == st[::-1] else False

s1=s[:len(s)//2]
s2=s[1+len(s)//2:]
if isp(s) and isp(s1) and isp(s2):
    print("Yes")
else:
    print("No")

Solution (Python):
S=input()
N = len(S)

T = S[:(N-1)//2]
U = S[(N+3)//2-1:]
if S==S[::-1] and T==T[::-1] and U==U[::-1]:
    print("Yes")
else:
    print("No")

Solution (Python):
def is_kaibun(word):
    result = True
    for i in range(len(word) // 2):
        if word[i] != word[len(word) - i - 1]:
            result = False
            break
    return result


def main():
    s = input()
    l = len(s)
    answer = is_kaibun(s) and is_kaibun(s[:(l - 1) // 2]) and is_kaibun(s[(l + 3) // 2 - 1:])
    print("Yes" if answer else "No")


if __name__ == '__main__':
    main()

Solution (Python):
s = input()
n = len(s)
m = (n-1)//2
if s != s[::-1]:
  print('No')
  exit()
t = s[:m]
if t != t[::-1]:
  print('No')
  exit()
if s[:m] != s[-m:]:
  print('No')
  exit()
print('Yes')

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

def func(s):
    return s == s[::-1]

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

Solution (Python):
s = input()
n = len(s)
t = s[:(n-1)//2]
u = s[(n+3)//2-1:]
if s==s[::-1] and t==t[::-1] and u==u[::-1]: print("Yes")
else: print("No")

Solution (Python):
s = input()
n = len(s) 
ans = "No"
if s[:n//2] == s[:n//2][::-1]:
    if s[-n//2 + 1:] == s[-n//2 + 1:][::-1]:
        if s == s[::-1]:
            ans = "Yes"
print(ans)

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    S=list(input())
    T=list(reversed(S))
    N=len(S)
    for a,b in zip(S,T):
        if a!=b:
            print('No')
            exit()
    U=S[:(N-1)//2]
    V=list(reversed(U))
    for a,b in zip(U,V):
        if a!=b:
            print('No')
            exit()
    print('Yes')
    

if __name__ == '__main__':
    main()

Solution (Python):
s = input()
n = len(s)
a = s[:(n-1)//2]
b = s[(n+1)//2:]
if s==s[::-1] and a==a[::-1] and b==b[::-1]:
  print("Yes")
else:
  print("No")

Solution (Python):
S = input()

N = len(S)
A = S[:N//2]
B = S[N//2 + 1:]

if S == S[::-1] and A == A[::-1] and B == B[::-1] :
  print('Yes')
else :
  print('No')

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

Solution (Python):
s = input()

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

s1 = s[:(len(s)-1)//2]
s2 = s[(len(s)+3)//2-1:]



if check(s) and check(s1) and check(s2):
    print("Yes")
else:
    print("No")

Solution (Python):
S = input()

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

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

s = ns()

def go(s):
    return s == s[::-1]

n = len(s)
print("Yes" if go(s) and go(s[0:(n-1)//2]) else "No")

Solution (Python):
import sys
input=lambda: sys.stdin.readline().rstrip()
S=input()
n=len(S)
if S==S[::-1] and S[:(n-1)//2]==S[(n+3)//2-1:]:
  
  print("Yes")
else:
  print("No")

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

po = input().split()[0]
n = len(po)
if po == po[::-1]:
    a = po[:n//2]
    b = po[n//2+1:]
    if a == a[::-1] and b == b[::-1]:
        print("Yes")
    else:
        print("No")
else:
    print("No")

Solution (Python):
s = input()
flag = 1

t = s[:(len(s)-1)//2]

for i in range(len(t)):
    if t[i] == t[-1-i]:
        continue
    else:
        flag = 0
t = s[(len(s)+3)//2-1:]
for i in range(len(t)):
    if t[i] == t[-1-i]:
        continue
    else:
        flag = 0
for i in range(len(s)):
    if s[i] == s[-1-i]:
        continue
    else:
        flag = 0
if flag == 1:
    print("Yes")
else:
    print("No")

Solution (Python):
s=input();n=len(s)
a,d=s[:(n-1)//2],s[(n+1)//2:]
print("Yes") if s==s[::-1]and a==a[::-1]and d[::-1]==d else print("No")

Solution (Python):
s = input()
n = len(s)
check = lambda x: x == x[::-1]
if check(s) and check(s[:(n-1)//2]) and check(s[(n+3)//2-1:]):
    print("Yes")
else:
    print("No")

Solution (Python):
S = input()

L = len(S)
T = S[::L//2]
U = S[L//2+1:]

if S[::-1] == S and T[::-1] == T and U[::-1] == U:
    print("Yes")
else:
    print("No")

Solution (Python):
s = input()

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

s2 = s[:(len(s) - 1) // 2]
s3 = s[(len(s) + 3) // 2 - 1: ]



if check(s) and check(s2) and check(s3):
    print('Yes')
else:
    print('No')

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


S = sys.stdin.buffer.readline().decode().rstrip()


def ok1():
    N = len(S)
    s = S[:(N - 1) // 2]
    return s == s[::-1]


def ok2():
    N = len(S)
    s = S[(N + 3) // 2 - 1:]
    return s == s[::-1]


ok = True
ok &= S == S[::-1]
ok &= ok1()
ok &= ok2()
if ok:
    print('Yes')
else:
    print('No')

Solution (Python):
s = input()

def isk(s):
    n = len(s)
    for i in range(n):
        if s[i] != s[n - 1 - i]:
            return False
    return True
n = len(s)
if isk(s) and isk(s[:(n - 1) // 2]) and isk(s[(n + 3) // 2 - 1:]):
    print('Yes')
else:
    print("No")

Solution (Python):
def kaibun(s):
    return s==s[::-1]

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

Solution (Python):
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])

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

Solution (Python):
s=input()
n=len(s)
m=(n-1)//2
j=(n+3)//2-1
t = s[:m]
u = s[j:]
if s == s[::-1] and t == t[::-1] and u == u[::-1]:
    print("Yes")
else:
    print("No")

Solution (Python):
def judge(x):
  n = len(x)
  flg = 1
  for i in range(n//2):
    if x[i] != x[-i-1]:
      flg = 0
  return flg
s = input()
n = len(s)
if judge(s) and judge(s[:n//2]):
  print("Yes")
else:
  print("No")

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

Solution (Python):
import sys
s = input()
if s == s[::-1]:
    x = s[:(len(s)-1)//2]
    if x == x[::-1]:
        y = s[(len(s)+3)//2 -1:]
        if y == y[::-1]:
            print('Yes')
            sys.exit()
print("No")

Solution (Python):
import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
    if f:
        print('Yes')
    else:
        print('No')
def Y(f):
    if f:
        print('YES')
    else:
        print('NO')
def Z(f):
    if f:
        print('Yay!')
    else:
        print(':(')
def ispow(n):
    if int(n**.5)**2==n:
        return True
    return False

s = input()
n = len(s)
a = s[:n//2]
b = s[(n+1)//2:]
def f(s):
    return s == s[::-1]
y(f(s) and f(a) and f(b))

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

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

main()