{-# LANGUAGE OverloadedStrings #-}
module Main where

import           Data.List
import           Control.Monad
import           Debug.Trace
import qualified Data.ByteString.Char8         as BC
import           Data.Maybe                     ( fromJust )
import qualified Data.Set                      as S
import qualified Data.IntMap.Strict            as IM
import qualified Data.Map.Strict               as M
import           Data.Char


readTuple2 :: IO (Int, Int)
readTuple2 = do
    [a, b] <- map (fst . fromJust . BC.readInt) . BC.words <$> BC.getLine
    return (a, b)

readTuple3 :: IO (Int, Int, Int)
readTuple3 = do
    [a, b, c] <- map (fst . fromJust . BC.readInt) . BC.words <$> BC.getLine
    return (a, b, c)

readInt :: IO Int
readInt = fst . fromJust . BC.readInt <$> BC.getLine

readInts :: IO [Int]
readInts = map (fst . fromJust . BC.readInt) . BC.words <$> BC.getLine

split :: (a -> Bool) -> [a] -> [[a]]
split f [] = []
split f as =
    let (fo, la) = span f as
        las      = case la of
            [] -> []
            xs -> split f $ tail xs
    in  case fo of
            [] -> las
            xs -> xs : las

isNum :: Int -> Bool
isNum a 
    | a `mod` 5 == 0 = False
    | a `mod` 3 == 0 = False
    | otherwise = True

lowerBound :: IM.IntMap Int -> Int -> Int -> Int -> Maybe Int
lowerBound m left right key 
        | satisfy leftVal = Just left
        | not $ satisfy rightVal = Nothing
        | right - left == 1 = Just right
        | otherwise = if satisfy (m IM.! mid) then lowerBound m left mid key else lowerBound m mid right key
        where
        leftVal = m IM.! left
        rightVal = m IM.! right
        satisfy val = val >= key
        mid = (right - left) `div` 2 + left

isKai :: String -> Bool
isKai s = reverse s == s

main = do
    s <- getLine
    let l = length s
    let fh = take ((l - 1) `div` 2) s
    let lh = drop (((l + 3) `div` 2) - 1) s
    putStrLn $ if isKai s && isKai fh && isKai lh then "Yes" else "No"



