#include <bits/stdc++.h>
using namespace std;
typedef struct d3point {
  long double x;
  long double y;
  long double z;
} d3point;
d3point make_d3point(long double arg1, long double arg2, long double arg3) {
  d3point *p = new d3point;
  p->x = arg1;
  p->y = arg2;
  p->z = arg3;
  return *p;
}
const double eps = 1e-15;
const int maxN = 1 * 100000 + 10, mod = (int)1e9 + 7;
void bfsM(int);
int lengthM(int, int);
void dijkstraM(int);
void dfsM(int);
long long chooseM(int, int);
void primeM(int);
long long powerM(int, int);
long double distanceM(d3point, d3point);
int gcdM(int, int);
string s;
int a[26], c;
int main(void) {
  ios_base::sync_with_stdio(0);
  cin >> s;
  for (int i = 0; i < s.length(); ++i) ++a[(s[i] - 'a')];
  for (int i = 0; i < 26; ++i)
    if (a[i] % 2) ++c;
  for (int i = 0; i < 26; ++i)
    if (a[i] % 2)
      if (c > 1)
        ++a[i], c -= 2;
      else if (c == 1)
        c = -i - 1;
      else
        --a[i];
  for (int i = 0; i < 26; ++i)
    for (int j = 0; j < a[i] / 2; ++j) cout << char('a' + i);
  if (c < 0) cout << char('a' - c - 1);
  for (int i = 26 - 1; i >= 0; --i)
    for (int j = 0; j < a[i] / 2; ++j) cout << char('a' + i);
  return 0;
}
void bfsM(bool mh, int i) {
  vector<int> v[maxN];
  bool mark[maxN];
  int prev[maxN];
  int dis[maxN];
  int n;
  int t;
  queue<int> que;
  que.push(i);
  mark[i] = 1;
  dis[i] = 0;
  while (!que.empty()) {
    t = que.front();
    que.pop();
    for (int j = 0; j < v[t].size(); ++j)
      if (!mark[v[t][j]]) {
        que.push(v[t][j]);
        mark[v[t][j]] = 1;
        dis[v[t][j]] = dis[t] + 1;
      }
  }
}
int lengthM(int n, int r) {
  int p = 0;
  while (n) {
    n /= r;
    ++p;
  }
  return p;
}
void dijkstraM(int i) {
  vector<pair<int, int> > v[maxN];
  int prev[maxN];
  int dis[maxN];
  int n;
  int q;
  set<pair<int, int> > st;
  dis[i] = 0;
  for (int j = 0; j < n; ++j) {
    if (i != j) dis[j] = INT_MAX;
    prev[j] = -1;
    st.insert(make_pair(dis[j], j));
  }
  while (!st.empty()) {
    q = st.begin()->second;
    st.erase(st.begin());
    for (int j = 0; j < (int)v[q].size(); ++j)
      if (dis[v[q][j].first] > dis[q] + v[q][j].second) {
        st.erase(make_pair(dis[v[q][j].first], v[q][j].first));
        dis[v[q][j].first] = dis[q] + v[q][j].second;
        prev[v[q][j].first] = q;
        st.insert(make_pair(dis[v[q][j].first], v[q][j].first));
      }
  }
}
void dfsM(int i) {
  bool mark[maxN] = {};
  vector<int> v[maxN];
  int prev[maxN];
  mark[i] = 1;
  for (int j = 0; j < (int)v[i].size(); ++j)
    if (!mark[v[i][j]]) {
      dfsM(v[i][j]);
      prev[v[i][j]] = i;
    }
}
long long chooseM(int arg1, int arg2) {
  long long tmp1 = 1, tmp2 = 1;
  if (arg2 > arg1 / 2) arg2 = arg1 - arg2;
  for (int i = 1; i <= arg2; ++i) {
    tmp1 = (tmp1 * i) % mod;
    tmp2 = (tmp2 * (arg1 - i + 1)) % mod;
  }
  return tmp2 * powerM((int)tmp1, mod - 2);
}
void primeM(int last) {
  bool isNotPrime[maxN] = {};
  int minPrime[maxN];
  vector<int> prime;
  for (int i = 2; i < last + 1; ++i)
    if (!isNotPrime[i]) {
      prime.push_back(i);
      for (int j = 2; j < last / i + 1; ++j) {
        isNotPrime[j * i] = 1;
        minPrime[i * j] = i;
      }
    }
}
long double distanceM(d3point d1, d3point d2) {
  return sqrt(pow(d1.x - d2.x, 2) + pow(d1.y - d2.y, 2) + pow(d1.z - d2.z, 2));
}
long long powerM(int arg1, int arg2) {
  if (arg2 == 0) return 1;
  long long pow = powerM(arg1, arg2 / 2);
  pow = (pow * pow) % mod;
  if (arg2 % 2 == 1) pow = (pow * arg1) % mod;
  return pow;
}
int gcdM(int arg1, int arg2) {
  if (arg1 < arg2) swap(arg1, arg2);
  while (0 < arg2) {
    arg1 -= (arg1 / arg2) * arg2;
    swap(arg1, arg2);
  }
  return arg1;
}

### Prompt

Your task is to create a CPP solution to the following problem:

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>
using namespace std;
typedef struct d3point {
  long double x;
  long double y;
  long double z;
} d3point;
d3point make_d3point(long double arg1, long double arg2, long double arg3) {
  d3point *p = new d3point;
  p->x = arg1;
  p->y = arg2;
  p->z = arg3;
  return *p;
}
const double eps = 1e-15;
const int maxN = 1 * 100000 + 10, mod = (int)1e9 + 7;
void bfsM(int);
int lengthM(int, int);
void dijkstraM(int);
void dfsM(int);
long long chooseM(int, int);
void primeM(int);
long long powerM(int, int);
long double distanceM(d3point, d3point);
int gcdM(int, int);
string s;
int a[26], c;
int main(void) {
  ios_base::sync_with_stdio(0);
  cin >> s;
  for (int i = 0; i < s.length(); ++i) ++a[(s[i] - 'a')];
  for (int i = 0; i < 26; ++i)
    if (a[i] % 2) ++c;
  for (int i = 0; i < 26; ++i)
    if (a[i] % 2)
      if (c > 1)
        ++a[i], c -= 2;
      else if (c == 1)
        c = -i - 1;
      else
        --a[i];
  for (int i = 0; i < 26; ++i)
    for (int j = 0; j < a[i] / 2; ++j) cout << char('a' + i);
  if (c < 0) cout << char('a' - c - 1);
  for (int i = 26 - 1; i >= 0; --i)
    for (int j = 0; j < a[i] / 2; ++j) cout << char('a' + i);
  return 0;
}
void bfsM(bool mh, int i) {
  vector<int> v[maxN];
  bool mark[maxN];
  int prev[maxN];
  int dis[maxN];
  int n;
  int t;
  queue<int> que;
  que.push(i);
  mark[i] = 1;
  dis[i] = 0;
  while (!que.empty()) {
    t = que.front();
    que.pop();
    for (int j = 0; j < v[t].size(); ++j)
      if (!mark[v[t][j]]) {
        que.push(v[t][j]);
        mark[v[t][j]] = 1;
        dis[v[t][j]] = dis[t] + 1;
      }
  }
}
int lengthM(int n, int r) {
  int p = 0;
  while (n) {
    n /= r;
    ++p;
  }
  return p;
}
void dijkstraM(int i) {
  vector<pair<int, int> > v[maxN];
  int prev[maxN];
  int dis[maxN];
  int n;
  int q;
  set<pair<int, int> > st;
  dis[i] = 0;
  for (int j = 0; j < n; ++j) {
    if (i != j) dis[j] = INT_MAX;
    prev[j] = -1;
    st.insert(make_pair(dis[j], j));
  }
  while (!st.empty()) {
    q = st.begin()->second;
    st.erase(st.begin());
    for (int j = 0; j < (int)v[q].size(); ++j)
      if (dis[v[q][j].first] > dis[q] + v[q][j].second) {
        st.erase(make_pair(dis[v[q][j].first], v[q][j].first));
        dis[v[q][j].first] = dis[q] + v[q][j].second;
        prev[v[q][j].first] = q;
        st.insert(make_pair(dis[v[q][j].first], v[q][j].first));
      }
  }
}
void dfsM(int i) {
  bool mark[maxN] = {};
  vector<int> v[maxN];
  int prev[maxN];
  mark[i] = 1;
  for (int j = 0; j < (int)v[i].size(); ++j)
    if (!mark[v[i][j]]) {
      dfsM(v[i][j]);
      prev[v[i][j]] = i;
    }
}
long long chooseM(int arg1, int arg2) {
  long long tmp1 = 1, tmp2 = 1;
  if (arg2 > arg1 / 2) arg2 = arg1 - arg2;
  for (int i = 1; i <= arg2; ++i) {
    tmp1 = (tmp1 * i) % mod;
    tmp2 = (tmp2 * (arg1 - i + 1)) % mod;
  }
  return tmp2 * powerM((int)tmp1, mod - 2);
}
void primeM(int last) {
  bool isNotPrime[maxN] = {};
  int minPrime[maxN];
  vector<int> prime;
  for (int i = 2; i < last + 1; ++i)
    if (!isNotPrime[i]) {
      prime.push_back(i);
      for (int j = 2; j < last / i + 1; ++j) {
        isNotPrime[j * i] = 1;
        minPrime[i * j] = i;
      }
    }
}
long double distanceM(d3point d1, d3point d2) {
  return sqrt(pow(d1.x - d2.x, 2) + pow(d1.y - d2.y, 2) + pow(d1.z - d2.z, 2));
}
long long powerM(int arg1, int arg2) {
  if (arg2 == 0) return 1;
  long long pow = powerM(arg1, arg2 / 2);
  pow = (pow * pow) % mod;
  if (arg2 % 2 == 1) pow = (pow * arg1) % mod;
  return pow;
}
int gcdM(int arg1, int arg2) {
  if (arg1 < arg2) swap(arg1, arg2);
  while (0 < arg2) {
    arg1 -= (arg1 / arg2) * arg2;
    swap(arg1, arg2);
  }
  return arg1;
}

```