//Jakub Staroń
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <unordered_map>
#include <unordered_set>

#ifdef COMPILING_HOME
#define DEBUG_MODE
#endif

using namespace std;

typedef char int8;
typedef unsigned char uint8;
typedef short int int16;
typedef unsigned short int uint16;
typedef int int32;
typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;

typedef std::pair <int32, int32> int32_pair;
typedef std::pair <uint32, uint32> uint32_pair;
typedef std::pair <int64, int64> int64_pair;
typedef std::pair <uint64, uint64> uint64_pair;

typedef std::vector<bool> bit_vector;

#ifdef DEBUG_MODE
#define debug_print(x) cerr << #x << " = " << x << endl
#define print_line cerr << "Line " << __LINE__ << endl
#include <cassert>
#else
#define debug_print(x)
#define print_line
#define assert(x)
#endif

#define rep(i, x) for(int32 i = 0 ; i < (x) ; i++)
#define for_range(i, begin, end) for(auto i = (begin) ; i != (end) ; ++i )
#define all(c) (c).begin(),(c).end()
#define sort_all(x) sort( all(x) )
#define divide(a, b) ( ( (b)%(a) ) == 0 )
#define mp(x, y) make_pair(x,y)
#define pb(x) push_back(x)

#define sig(x) ( (x) == 0 ? 0 : ( (x) < 0 ? -1 : 1 ) )

const double epsilon = 1e-5;

template<class T>
void unique(std::vector <T> &v) {
  sort_all(v);
  v.resize(std::unique(all(v)) - v.begin());
}

ostream &newline(ostream &str) {
  str.put('\n');
  return str;
}

template<typename T1, typename T2>
istream &operator>>(istream &stream, std::pair <T1, T2> &pair) {
  stream >> pair.first >> pair.second;
  return stream;
}

template<typename T1, typename T2>
ostream &operator<<(ostream &stream, const std::pair <T1, T2> &pair) {
#ifdef DEBUG_MODE
  stream << "(" << pair.first << ", " << pair.second << ")";
#else
  stream << pair.first << ' ' << pair.second;
#endif
  return stream;
}

template<class T>
inline pair <T, T> operator+(const pair <T, T> &a, const pair <T, T> &b) {
  return pair<T, T>(a.first + b.first, a.second + b.second);
}

template<class T>
inline pair <T, T> operator-(const pair <T, T> &a, const pair <T, T> &b) {
  return pair<T, T>(a.first - b.first, a.second - b.second);
}

template<class T>
ostream &operator<<(ostream &str, const vector <T> &v) {
  if (!v.empty()) {
    for (int32 i = 0; i + 1 < v.size(); i++)
      str << v[i] << ' ';
    str << v.back();
  }
  return str;
}

class Application {
 public:
  Application() {
  }

  void Run() {
    WczytajDane();
    uint64 sum = 0;
    uint32 smallest_even = 1001;

    rep(i, N) {
      uint32 k;
      cin >> k;
      sum += k;
      if (!divide(2, k) && k < smallest_even)
        smallest_even = k;
    }

    if (N == 1 && !divide(2, sum)) {
      cout << "NIESTETY" << newline;
    }
    else if (divide(2, sum)) {
      cout << sum << newline;
    }
    else {
      cout << (sum - smallest_even) << newline;
    }
  }

  void WczytajDane() {
    cin >> N;
  }

  uint32 N;
  vector <uint32> A;
};


int main() {
  ios::sync_with_stdio(0);
  Application application;
  application.Run();
  return 0;
}