Problem: Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome. 

A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.

Input

The first and single line contains string s (1 ≤ |s| ≤ 15).

Output

Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise. 

Examples

Input

abccaa


Output

YES


Input

abbcca


Output

NO


Input

abcda


Output

YES

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import java.math.BigInteger;

@SuppressWarnings("unchecked")
public class Main {

	final static boolean fileIO = false;
	final static boolean DEBUG = false;


	final static int INF = 0x7FFFFFFF;
	final static int EPS = (int)1e9 + 7;

	static class Pair<K,V> {
		K fs;
		V sc;
		public Pair(K fs, V sc) { this.fs = fs; this.sc = sc; }
		@Override
		public String toString() { return fs.toString() + " " + sc.toString(); }
	}

	static class PLL {
		long fs;
		long sc;
		int id;
		public PLL(long fs, long sc, int id) { this.fs = fs; this.sc = sc; this.id = id; }
		public PLL(long fs, long sc) { this.fs = fs; this.sc = sc; this.id = -1; }
		@Override
		public String toString() { return Long.toString(fs) + " " + Long.toString(sc); }
	}

	static class PII {
		int fs;
		int sc;
		int id;
		public PII(int fs, int sc, int id) { this.fs = fs; this.sc = sc; this.id = id; }
		public PII(int fs, int sc) { this.fs = fs; this.sc = sc; this.id = -1; }
		@Override
		public String toString() { return Integer.toString(fs) + " " + Integer.toString(sc); }
	}

	public static void main(String args[]) throws IOException {
		InputStream is;
		OutputStream os;
		if (fileIO) {
			is = new FileInputStream("input.txt");
			os = new FileOutputStream("output.txt");
		} else {
			is = System.in;
			os = System.out;
		}
		InputReader in = new InputReader(is);
		PrintWriter out = new PrintWriter(os);
		new Task().solve(in, out);
		out.close();
	}


	static class Task {

		public void solve(InputReader in, PrintWriter out) {
			char s[] = in.next().toCharArray();
			boolean ans = true;
			//
			for (int j = 0; j < s.length / 2; j++) {

				if (s[j] != s[s.length - 1 - j]) ans = false;
			}
			if (ans && s.length % 2 == 0) {
				out.println("NO");
			} else {
			//
			for (int i = 0; i < s.length; i++) {
				char t[] = Arrays.copyOf(s, s.length);
				for (int c = 0; c < 26; c++) {
					t[i] = (char)(c + (int)('a'));
					boolean candidate = true;
					for (int j = 0; j < t.length / 2; j++) {
						if (t[j] != t[t.length - 1 - j]) {
							candidate = false;
						}
					}
					if (candidate) ans = true;
				}
			}
			out.println(ans ? "YES" : "NO");
		}
		}

	}

	static class Task_B {

		public void solve(InputReader in, PrintWriter out) {
			int n = in.nI();
			char a[][] = new char[n][];
			for (int i = 0; i < n; i++) {
				a[i] = in.next().toCharArray();
			}
			//
			int ans = INF;
			for (int can = 0; can < n; can++) {
				int ret = 0;
				for (int i = 0; i < n; i++) {
					if (i == can) continue;
					//
					int len = a[i].length;
					char t[] = new char[len];
					boolean yes = true;
					for (int shift = 0; shift < len && yes; shift++) {
						//

						for (int j = 0; j < len; j++) {
							t[(j - shift + len) % len] = a[i][j];
						}
						if (Arrays.equals(a[can], t)) {
							ret += shift;
							yes = false;
						}
					}
					if (yes) break;
					//
				}
				ans = Math.min(ans, ret);
			}
			out.println(ans == INF ? "-1" : ans);
		}
	}


	static class InputReader {

		private StringTokenizer tokenizer;
		private BufferedReader reader;

		public InputReader(InputStream is) {
			tokenizer = null;
			reader = new BufferedReader(new InputStreamReader(is), 32768);
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					String line = reader.readLine();
					if (line == null) return null;
					tokenizer = new StringTokenizer(line);
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public Integer nI() { return Integer.parseInt(next()); }
		public Integer[] nIA(int n) {
			Integer ret[] = new Integer[n];
			int i = 0;
			while (n-- > 0) ret[i++] = nI();
			return ret;
		}
		public Long nL() { return Long.parseLong(next()); }
		public Long[] nLA(int n) {
			Long ret[] = new Long[n];
			int i = 0;
			while (n-- > 0) ret[i++] = nL();
			return ret;
		}
	}
}