#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
const long long mod = 998244353ll;
struct mint {
  long long x;
  mint(long long x = 0) : x((x % mod + mod) % mod) {}
  mint operator-() const { return mint(-x); }
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod - a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const { return mint(*this) += a; }
  mint operator-(const mint a) const { return mint(*this) -= a; }
  mint operator*(const mint a) const { return mint(*this) *= a; }
  mint pow(long long t) const {
    if (!t) return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1) a *= *this;
    return a;
  }
  mint inv() const { return pow(mod - 2); }
  mint& operator/=(const mint a) { return *this *= a.inv(); }
  mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
long long ceili(long long a, long long b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
const long long INF64 = 4223372036854775807ll;
const long long MOD = 998244353ll;
const long long OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n) {
  long long resize = 1;
  while (n > 0) {
    if (n & 1) resize = resize * a % MOD;
    a = a * a % MOD;
    n >>= 1;
  }
  return resize;
}
int main() {
  string s;
  std::cin >> s;
  int n = s.size();
  std::vector<int> c(26);
  for (auto& i : s) {
    c[i - 'a']++;
  }
  std::vector<int> v;
  for (long long i = 0; i < (long long)(26); i++) {
    if (c[i] % 2 != 0) v.push_back(i);
  }
  while (v.size() >= 2) {
    c[v[0]]++;
    c[v[v.size() - 1]]--;
    v.erase(v.begin());
    v.pop_back();
  }
  char od = '?';
  string ans;
  for (long long i = 0; i < (long long)(26); i++) {
    if (c[i] % 2 == 1) od = i + 'a';
    for (long long ii = 0; ii < (long long)(c[i] / 2); ii++)
      ans.push_back(i + 'a');
  }
  string ians = ans;
  reverse((ians).begin(), (ians).end());
  if (n % 2 == 0) {
    std::cout << ans + ians << std::endl;
  } else
    std::cout << ans + od + ians << std::endl;
}

### Prompt

Please provide a Cpp coded solution to the problem described below:

A string is called palindrome if it reads the same from left to right and from right to left. For example "kazak", "oo", "r" and "mikhailrubinchikkihcniburliahkim" are palindroms, but strings "abb" and "ij" are not.

You are given string s consisting of lowercase Latin letters. At once you can choose any position in the string and change letter in that position to any other lowercase letter. So after each changing the length of the string doesn't change. At first you can change some letters in s. Then you can permute the order of letters as you want. Permutation doesn't count as changes. 

You should obtain palindrome with the minimal number of changes. If there are several ways to do that you should get the lexicographically (alphabetically) smallest palindrome. So firstly you should minimize the number of changes and then minimize the palindrome lexicographically.

Input

The only line contains string s (1 ≤ |s| ≤ 2·105) consisting of only lowercase Latin letters.

Output

Print the lexicographically smallest palindrome that can be obtained with the minimal number of changes.

Examples

Input

aabc


Output

abba


Input

aabcd


Output

abcba

### Response

```cpp
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
const long long mod = 998244353ll;
struct mint {
  long long x;
  mint(long long x = 0) : x((x % mod + mod) % mod) {}
  mint operator-() const { return mint(-x); }
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod - a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const { return mint(*this) += a; }
  mint operator-(const mint a) const { return mint(*this) -= a; }
  mint operator*(const mint a) const { return mint(*this) *= a; }
  mint pow(long long t) const {
    if (!t) return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1) a *= *this;
    return a;
  }
  mint inv() const { return pow(mod - 2); }
  mint& operator/=(const mint a) { return *this *= a.inv(); }
  mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
long long ceili(long long a, long long b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
const long long INF64 = 4223372036854775807ll;
const long long MOD = 998244353ll;
const long long OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n) {
  long long resize = 1;
  while (n > 0) {
    if (n & 1) resize = resize * a % MOD;
    a = a * a % MOD;
    n >>= 1;
  }
  return resize;
}
int main() {
  string s;
  std::cin >> s;
  int n = s.size();
  std::vector<int> c(26);
  for (auto& i : s) {
    c[i - 'a']++;
  }
  std::vector<int> v;
  for (long long i = 0; i < (long long)(26); i++) {
    if (c[i] % 2 != 0) v.push_back(i);
  }
  while (v.size() >= 2) {
    c[v[0]]++;
    c[v[v.size() - 1]]--;
    v.erase(v.begin());
    v.pop_back();
  }
  char od = '?';
  string ans;
  for (long long i = 0; i < (long long)(26); i++) {
    if (c[i] % 2 == 1) od = i + 'a';
    for (long long ii = 0; ii < (long long)(c[i] / 2); ii++)
      ans.push_back(i + 'a');
  }
  string ians = ans;
  reverse((ians).begin(), (ians).end());
  if (n % 2 == 0) {
    std::cout << ans + ians << std::endl;
  } else
    std::cout << ans + od + ians << std::endl;
}

```