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 in Rust (1.15.1) (judge verdict: Wrong Answer)

fn main() {
    let s: String = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().to_owned()
    };

    let s_len = s.chars().count();
    let s_half_len = (s_len - 1) / 2;

    let before = s.chars().take(s_half_len).collect::<String>();
    let after = s.chars().skip(s_half_len + 1).collect::<String>();
    if before == after {
        let is_half_odd = s_half_len % 2 == 1;
        let s_half_half_len = if is_half_odd {
            (s_half_len - 1) / 2
        } else {
            s_half_len / 2
        };
        let before = s.chars().take(s_half_half_len).collect::<String>();
        let skip_index = if is_half_odd {
            s_half_half_len + 1
        } else {
            s_half_half_len
        };
        let after = s
            .chars()
            .skip(skip_index)
            .take(s_half_half_len)
            .collect::<String>();
        if before == after {
            println!("Yes");
        } else {
            println!("No");
        }
    } else {
        println!("No");
    }
}

// 回文であることを判定する
// trueなら1-(n-1)/2文字目が回文であることを判定する