#include <bits/stdc++.h>
const double EPS = 1e-8;
using namespace std;
long long gcd(long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
  std::fill((T *)array, (T *)(array + N), val);
}
int gcd(int a, int b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
pair<int, int> Dir[8] = {{0, 1}, {-1, 0}, {1, 0},  {0, -1},
                         {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
pair<int, int> operator+(pair<int, int> obj, pair<int, int> obj2) {
  return make_pair((obj.first + obj2.first), (obj.second + obj2.second));
}
pair<int, int> operator-(pair<int, int> obj, pair<int, int> obj2) {
  return make_pair((obj.first - obj2.first), (obj.second - obj2.second));
}
template <class T, class OP, class PROP>
class Lazy_Segment_Tree {
 public:
  vector<T> data, lazy;
  vector<bool> isupd;
  int n;
  Lazy_Segment_Tree(int a) : n(1) {
    while (n < a) n *= 2;
    data.resize(n * 2 - 1);
    lazy.resize(n * 2 - 1);
    isupd.resize(n * 2 - 1);
  }
  void prop(int num, int s) {
    if (isupd[num]) {
      data[num] = PROP()(data[num], lazy[num], 1, s);
      if (num < n - 1) {
        lazy[num * 2 + 1] = PROP()(lazy[num * 2 + 1], lazy[num]);
        lazy[num * 2 + 2] = PROP()(lazy[num * 2 + 2], lazy[num]);
        isupd[num * 2 + 1] = 1;
        isupd[num * 2 + 2] = 1;
      }
      lazy[num] = T();
      isupd[num] = 0;
    }
  }
  void op(int a, int b, T v, int num = 0, int base = 1) {
    int l = (num + 1 - base) * (n / base), r = l + n / base;
    prop(num, r - l);
    if (a == l && b == r) {
      isupd[num] = 1;
      lazy[num] = PROP()(lazy[num], v);
      prop(num, r - l);
    } else {
      int nr = (l + r) / 2;
      if (nr > a) op(a, min(b, nr), v, num * 2 + 1, base * 2);
      if (nr < b) op(max(a, nr), b, v, num * 2 + 2, base * 2);
      prop(num * 2 + 1, (r - l) / 2), prop(num * 2 + 2, (r - l) / 2);
      data[num] = OP()(data[num * 2 + 1], data[num * 2 + 2]);
    }
  }
  T query(int a, int b, int num = 0, int base = 1) {
    int l = (num + 1 - base) * (n / base), r = l + n / base;
    prop(num, r - l);
    if (a == l && b == r)
      return data[num];
    else {
      int nr = (l + r) / 2;
      T ret = T();
      if (nr > a) ret = OP()(ret, query(a, min(b, nr), num * 2 + 1, base * 2));
      if (nr < b) ret = OP()(ret, query(max(a, nr), b, num * 2 + 2, base * 2));
      return ret;
    }
  }
};
template <class T>
class ADD {
 public:
  T operator()(const T a, const T b, const int ra = 1, int rb = 1) {
    return a * ra + b * rb;
  }
};
template <class T>
class UPD {
 public:
  T operator()(const T a, const T b, const int ra = 1, int rb = 1) { return b; }
};
template <class T>
class RMQ {
 public:
  T operator()(const T a, const T b) { return min(a, b); }
};
template <class T>
class SUM {
 public:
  T operator()(const T a, const T b) { return a + b; }
};
struct N {
 public:
  int num;
  N(int num) : num(num) {}
  N() : num(1000000) {}
  N operator+(const N obj) const { return N(obj.num + num); }
  N operator*(const N obj) const { return N(obj.num * num); }
  bool operator<(const N obj) const { return obj.num > num; }
};
int main() {
  string str;
  cin >> str;
  int count['z' - 'a' + 1] = {};
  for (auto itr : str) count[itr - 'a']++;
  int ans = 0;
  for (int i = (0); ('z' - 'a' + 1) > i; i++) ans += count[i] % 2;
  cout << max(1, ans) << endl;
  return 0;
}
