#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
constexpr long long mod = 1000000007;
const double eps = pow(10, -9);
pair<long long, long long> bisearch(long long l, long long r,
                                    function<bool(long long)> f) {
  while ((l + 1) < r) {
    long long m = (l + r) / 2;
    if (f(m))
      r = m;
    else
      l = m;
  }
  return pair<long long, long long>(l, r);
}
long long SQRT(long long n) {
  return bisearch(0, n, [n](long long x) { return x * x > n; }).first;
}
bool square(long long a) {
  long long n = SQRT(a);
  return a == n * n;
}
long long mpow(long long x, long long n) {
  long long ans = 1;
  while (n != 0) {
    if (n & 1) ans = ans * x % mod;
    x = x * x % mod;
    n = n >> 1;
  }
  return ans;
}
long long inv_mod(long long a) { return mpow(a, mod - 2); }
int digitsum(long long N, int a) {
  if (N == 0) return 0;
  int ret = 0;
  ret += digitsum(N / a, a) + N % a;
  return ret;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; };
long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
void YN(bool flg) { cout << (flg ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << (flg ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << (flg ? "yes" : "no") << endl; }
vector<long long> splitint(string n, int a) {
  int Len = n.length();
  if (a < 0 || Len < a) return {-1, -1};
  string left, right;
  if (a != 0) left = n.substr(0, a);
  if (a != Len) right = n.substr(a);
  return {stoll(left), stoll(right)};
}
class Ruiseki {
 private:
  vector<long long> LEFT, RIGHT;
  function<long long(long long, long long)> F;
  int N;

 public:
  Ruiseki(long long INI, vector<long long> a,
          function<long long(long long, long long)> f) {
    N = a.size();
    F = f;
    LEFT.resize(N + 1);
    RIGHT.resize(N + 1);
    LEFT[0] = RIGHT[0] = INI;
    for (int i = 0, i_len = (N); i < i_len; ++i) {
      LEFT[i + 1] = F(LEFT[i], a[i]);
      RIGHT[i + 1] = F(RIGHT[i], a[N - i - 1]);
    }
  }
  long long out(int l, int r) { return F(LEFT[l], RIGHT[N - r]); }
};
class mint {
 private:
  long long _num, _mod;
  mint set(long long num) {
    _num = num;
    if (_num >= 0)
      _num %= _mod;
    else
      _num += (1 - (_num + 1) / _mod) * _mod;
    return *this;
  }
  long long imod(long long n) { return mpow(n, _mod - 2); }

 public:
  mint() {
    _num = 0;
    _mod = mod;
  }
  mint(long long num) {
    _mod = mod;
    _num = num % mod;
  }
  mint(long long num, long long M) {
    _mod = M;
    set(num);
  }
  mint(const mint &cp) {
    _num = cp._num;
    _mod = cp._mod;
  }
  mint operator=(long long x) { return set(x); }
  mint operator+(long long x) { return mint(_num + (x % _mod), _mod); }
  mint operator-(long long x) { return mint(_num - (x % _mod), _mod); }
  mint operator*(long long x) { return mint(_num * (x % _mod), _mod); }
  mint operator/(long long x) { return mint(_num * imod(x), _mod); }
  mint operator+=(long long x) { return set(_num + (x % _mod)); }
  mint operator-=(long long x) { return set(_num - (x % _mod)); }
  mint operator*=(long long x) { return set(_num * (x % _mod)); }
  mint operator/=(long long x) { return set(_num * imod(x)); }
  mint operator+(mint x) { return mint(_num + x._num, _mod); }
  mint operator-(mint x) { return mint(_num - x._num, _mod); }
  mint operator*(mint x) { return mint(_num * x._num, _mod); }
  mint operator/(mint x) { return mint(_num * imod(x._num), _mod); }
  mint operator+=(mint x) { return set(_num + x._num); }
  mint operator-=(mint x) { return set(_num - x._num); }
  mint operator*=(mint x) { return set(_num * x._num); }
  mint operator/=(mint x) { return set(_num * imod(x._num)); }
  friend mint operator+(long long x, mint m) {
    return mint(m._num + (x % m._mod), m._mod);
  }
  friend mint operator-(long long x, mint m) {
    return mint(m._num - (x % m._mod), m._mod);
  }
  friend mint operator*(long long x, mint m) {
    return mint(m._num * (x % m._mod), m._mod);
  }
  friend mint operator/(long long x, mint m) {
    return mint(m.imod(m._num) * x, m._mod);
  }
  explicit operator long long() { return _num; }
  explicit operator int() { return _num; }
  friend ostream &operator<<(ostream &os, const mint &x) {
    os << x._num;
    return os;
  }
  friend istream &operator>>(istream &is, mint &x) {
    long long val;
    is >> val;
    x.set(val);
    return is;
  }
};
template <typename T>
class MAT {
 private:
  int row, col;
  vector<vector<T>> _A;
  MAT set(vector<vector<T>> A) {
    _A = A;
    return *this;
  }

 public:
  MAT() {}
  MAT(int n, int m) {
    if (n < 1 || m < 0) {
      cout << "err Matrix::Matrix" << endl;
      exit(1);
    }
    row = n;
    col = m ? m : n;
    for (int i = 0, i_len = (row); i < i_len; ++i) {
      vector<T> a(col);
      _A.push_back(a);
      for (int j = 0, j_len = (col); j < j_len; ++j) _A[i][j] = 0;
    }
    if (m == 0)
      for (int i = 0, i_len = (n); i < i_len; ++i) _A[i][i] = 1.0;
  }
  MAT(const MAT &cp) {
    _A = cp._A;
    row = cp.row;
    col = cp.col;
  }
  T *operator[](int i) { return _A[i].data(); }
  MAT operator=(vector<vector<T>> x) { return set(x); }
  MAT operator+(MAT x) {
    if (row != x.row || col != x.col) {
      cout << "err Matrix::operator+" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (col); j < j_len; ++j)
        r[i][j] = _A[i][j] + x[i][j];
    return r;
  }
  MAT operator-(MAT x) {
    if (row != x.row || col != x.col) {
      cout << "err Matrix::operator-" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (col); j < j_len; ++j)
        r[i][j] = _A[i][j] - x[i][j];
    return r;
  }
  MAT operator*(MAT x) {
    if (col != x.row) {
      cout << "err Matrix::operator*" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, x.col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (x.col); j < j_len; ++j)
        for (int k = 0, k_len = (col); k < k_len; ++k)
          r[i][j] += _A[i][k] * x[k][j];
    return r;
  }
  MAT operator/(T a) {
    MAT r(row, col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (col); j < j_len; ++j) r[i][j] = _A[i][j] / a;
    return r;
  }
  MAT operator^(long long n) {
    if (row != col) {
      cout << "err Matrix::operator^" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, 0), A = *this;
    while (n) {
      if (n & 1) r *= A;
      A *= A;
      n >>= 1;
    }
    return r;
  }
  MAT operator+=(MAT x) {
    if (row != x.row || col != x.col) {
      cout << "err Matrix::operator+=" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (col); j < j_len; ++j)
        r[i][j] = _A[i][j] + x[i][j];
    return set(r._A);
  }
  MAT operator-=(MAT x) {
    if (row != x.row || col != x.col) {
      cout << "err Matrix::operator-=" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (col); j < j_len; ++j)
        r[i][j] = _A[i][j] - x[i][j];
    return set(r._A);
  }
  MAT operator*=(MAT x) {
    if (col != x.row) {
      cout << "err Matrix::operator*" << endl;
      cout << "  not equal matrix size" << endl;
      exit(0);
    }
    MAT r(row, x.col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (x.col); j < j_len; ++j)
        for (int k = 0, k_len = (col); k < k_len; ++k)
          r[i][j] += _A[i][k] * x[k][j];
    return set(r._A);
  }
  MAT operator/=(T a) {
    MAT r(row, col);
    for (int i = 0, i_len = (row); i < i_len; ++i)
      for (int j = 0, j_len = (col); j < j_len; ++j) r[i][j] = _A[i][j] / a;
    return r;
  }
  friend MAT operator*(T n, MAT x) {
    MAT r(x.row, x.col);
    for (int i = 0, i_len = (x.row); i < i_len; ++i)
      for (int j = 0, j_len = (x.col); j < j_len; ++j) r[i][j] = n * x[i][j];
    return r;
  }
  friend MAT operator*(MAT x, T n) {
    MAT r(x.row, x.col);
    for (int i = 0, i_len = (x.row); i < i_len; ++i)
      for (int j = 0, j_len = (x.col); j < j_len; ++j) r[i][j] = n * x[i][j];
    return r;
  }
  explicit operator vector<vector<T>>() { return _A; }
  friend ostream &operator<<(ostream &os, const MAT &x) {
    for (int i = 0, i_len = (x.row); i < i_len; ++i)
      for (int j = 0, j_len = (x.col); j < j_len; ++j)
        os << x._A[i][j] << " \n"[j == x.col - 1];
    return os;
  }
  int size_row() { return row; }
  int size_col() { return col; }
  MAT transpose() {
    MAT r(col, row);
    for (int i = 0, i_len = (col); i < i_len; ++i)
      for (int j = 0, j_len = (row); j < j_len; ++j) r[i][j] = _A[j][i];
    return r;
  }
  MAT inverse() {
    double buf;
    MAT<double> inv_a(row, 0);
    MAT<double> a = _A;
    for (int i = 0, i_len = (row); i < i_len; ++i) {
      buf = 1 / a[i][i];
      for (int j = 0, j_len = (row); j < j_len; ++j) {
        a[i][j] *= buf;
        inv_a[i][j] *= buf;
      }
      for (int j = 0, j_len = (row); j < j_len; ++j) {
        if (i != j) {
          buf = a[j][i];
          for (int k = 0, k_len = (row); k < k_len; ++k) {
            a[j][k] -= a[i][k] * buf;
            inv_a[j][k] -= inv_a[i][k] * buf;
          }
        }
      }
    }
    return inv_a;
  }
  int rank() {
    MAT A = _A;
    const int n = row, m = col;
    int r = 0;
    for (int i = 0; r < n && i < m; ++i) {
      int pivot = r;
      for (int j = r + 1; j < n; ++j)
        if (abs(A[j][i]) > abs(A[pivot][i])) pivot = j;
      swap(A[pivot], A[r]);
      if (abs(A[r][i]) < eps) continue;
      for (int k = m - 1; k >= i; --k) A[r][k] /= A[r][i];
      for (int j = int(r + 1); j < int(n); ++j)
        for (int k = int(i); k < int(m); ++k) A[j][k] -= A[r][k] * A[j][i];
      ++r;
    }
    return r;
  }
};
class UnionFind {
 private:
  vector<int> Parent;

 public:
  UnionFind(int N) {
    Parent.resize(N);
    for (int i = 0, i_len = (N); i < i_len; ++i) Parent[i] = -1;
  }
  int root(int A) {
    if (Parent[A] < 0)
      return A;
    else
      return Parent[A] = root(Parent[A]);
  }
  int size(int A) { return -Parent[root(A)]; }
  bool connect(int A, int B) {
    A = root(A);
    B = root(B);
    if (A == B) return false;
    if (size(A) < size(B)) swap(A, B);
    Parent[A] += Parent[B];
    Parent[B] = A;
    return true;
  }
};
class Factorial {
 private:
  vector<long long> fac;
  vector<long long> ifac;

 public:
  Factorial(long long N) {
    fac.push_back(1);
    for (int i = 0, i_len = (N); i < i_len; ++i)
      fac.push_back(fac[i] * (i + 1) % mod);
    ifac.resize(N + 1);
    ifac[N] = inv_mod(fac[N]);
    for (int i = 0, i_len = (N); i < i_len; ++i)
      ifac[N - 1 - i] = (ifac[N - i] * (N - i)) % mod;
  }
  long long fact(long long a) { return fac[a]; }
  long long ifact(long long a) { return ifac[a]; }
  long long cmb(long long a, long long b) {
    if (a == 0 && b == 0) return 1;
    if (a < b || a < 0 || b < 0) return 0;
    long long tmp = ifact(a - b) * ifact(b) % mod;
    return tmp * fac[a] % mod;
  }
  long long per(long long a, long long b) {
    if (a == 0 && b == 0) return 1;
    if (a < b || a < 0 || b < 0) return 0;
    return fac[a] * ifac[a - b] % mod;
  }
};
class SOSU {
 private:
  vector<long long> Prime_Number;

 public:
  SOSU(int N) {
    set<long long> arr;
    for (int i = 0, i_len = (N - 1); i < i_len; ++i) arr.insert(i + 2);
    while (int n = *arr.begin()) {
      if (n > sqrt(N)) break;
      Prime_Number.push_back(n);
      for (int i = int(1); i < int(N / n + 1); ++i) arr.erase(n * i);
    }
    for (auto itr = (arr).begin(); itr != (arr).end(); ++itr)
      Prime_Number.push_back(*itr);
  }
  long long operator[](int i) { return Prime_Number[i]; }
  int count() { return Prime_Number.size(); }
  bool isPrime(int q) {
    return binary_search((Prime_Number).begin(), (Prime_Number).end(), q);
  }
};
struct Solutions {
  long long napsack(int kinds, int MAX_W, const vector<long long> weight,
                    const vector<long long> cost) {
    vector<vector<long long>> dp(kinds + 1, vector<long long>(MAX_W + 1, 0));
    for (int i = 0, i_len = (kinds); i < i_len; ++i)
      for (int j = 0, j_len = (MAX_W + 1); j < j_len; ++j) {
        if (j < weight[i])
          dp[i + 1][j] = dp[i][j];
        else
          dp[i + 1][j] = max(dp[i][j], dp[i][j - weight[i]] + cost[i]);
      }
    return dp[kinds][MAX_W];
  }
  long long unlimited_napsack(int kinds, int MAX_W,
                              const vector<long long> weight,
                              const vector<long long> cost) {
    vector<vector<long long>> dp(kinds + 1, vector<long long>(MAX_W + 1, 0));
    for (int i = 0, i_len = (kinds); i < i_len; ++i)
      for (int j = 0, j_len = (MAX_W + 1); j < j_len; ++j) {
        if (j < weight[i])
          dp[i + 1][j] = dp[i][j];
        else
          dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - weight[i]] + cost[i]);
      }
    return dp[kinds][MAX_W];
  }
  long long Partition_Func(int n, int k) {
    vector<vector<long long>> dp(k + 1, vector<long long>(n + 1, 0));
    dp[0][0] = 1;
    for (int i = int(1); i < int(k + 1); ++i)
      for (int j = 0, j_len = (n + 1); j < j_len; ++j) {
        if (j - i >= 0)
          dp[i][j] = (dp[i][j - i] + dp[i - 1][j]);
        else
          dp[i][j] = dp[i - 1][j];
      }
    return dp[k][n];
  }
  int LCS(string s, string t) {
    int n = s.length(), m = s.length();
    vector<vector<int>> dp(n + 1, vector<int>(m + 1));
    for (int i = 0, i_len = (n); i < i_len; ++i)
      for (int j = 0, j_len = (m); j < j_len; ++j) {
        if (s[i] == t[j])
          dp[i + 1][j + 1] = dp[i][j] + 1;
        else
          dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);
      }
    return dp[n][m];
  }
  int LIS(const vector<long long> a) {
    int n = a.size();
    long long INF = 1 << 28;
    vector<long long> dp(n + 1, INF);
    for (int i = 0, i_len = (n); i < i_len; ++i)
      *lower_bound((dp).begin(), (dp).end(), a[i]) = a[i];
    int k = lower_bound((dp).begin(), (dp).end(), INF) - dp.begin();
    return k;
  }
};
struct edge {
  int from;
  int to;
  long long cost;
  void push(int a, int b, int c) {
    from = a;
    to = b;
    cost = c;
  }
  bool operator<(const edge &y) const {
    if (cost != y.cost)
      return cost < y.cost;
    else if (to != y.to)
      return to < y.to;
    else
      return from < y.from;
  }
  bool operator>(const edge &y) const {
    if (cost != y.cost)
      return cost > y.cost;
    else if (to != y.to)
      return to > y.to;
    else
      return from > y.from;
  }
  bool operator==(const edge &y) const { return *this == y; }
};
class lca {
 public:
  const int n = 0;
  const int log2_n = 0;
  std::vector<std::vector<int>> parent;
  std::vector<int> depth;
  lca() {}
  lca(const Graph &g, int root)
      : n(g.size()),
        log2_n(log2(n) + 1),
        parent(log2_n, std::vector<int>(n)),
        depth(n) {
    dfs(g, root, -1, 0);
    for (int k = 0; k + 1 < log2_n; k++) {
      for (int v = 0; v < (int)g.size(); v++) {
        if (parent[k][v] < 0)
          parent[k + 1][v] = -1;
        else
          parent[k + 1][v] = parent[k][parent[k][v]];
      }
    }
  }
  void dfs(const Graph &g, int v, int p, int d) {
    parent[0][v] = p;
    depth[v] = d;
    for (int j = 0, j_len = (g[v].size()); j < j_len; ++j) {
      if (g[v][j] != p) dfs(g, g[v][j], v, d + 1);
    }
  }
  int get(int u, int v) {
    if (depth[u] > depth[v]) std::swap(u, v);
    for (int k = 0; k < log2_n; k++) {
      if ((depth[v] - depth[u]) >> k & 1) {
        v = parent[k][v];
      }
    }
    if (u == v) return u;
    for (int k = log2_n - 1; k >= 0; k--) {
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    }
    return parent[0][u];
  }
};
template <typename T, typename E>
struct SegmentTree {
  typedef function<T(T, T)> F;
  typedef function<T(T, E)> G;
  int n;
  F f;
  G g;
  T d1;
  E d0;
  vector<T> dat;
  SegmentTree(){};
  SegmentTree(int n_, F f, G g, T d1, vector<T> v = vector<T>())
      : f(f), g(g), d1(d1) {
    init(n_);
    if (n_ == (int)v.size()) build(n_, v);
  }
  void init(int n_) {
    n = 1;
    while (n < n_) n *= 2;
    dat.clear();
    dat.resize(2 * n - 1, d1);
  }
  void build(int n_, vector<T> v) {
    for (int i = 0; i < n_; i++) dat[i + n - 1] = v[i];
    for (int i = n - 2; i >= 0; i--) dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
  }
  void update(int k, E a) {
    k += n - 1;
    dat[k] = g(dat[k], a);
    while (k > 0) {
      k = (k - 1) / 2;
      dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
    }
  }
  inline T query(int a, int b) {
    T vector<long long> = d1, vr = d1;
    for (int l = a + n, r = b + n; l < r; l >>= 1, r >>= 1) {
      if (l & 1) vector<long long> = f(vector<long long>, dat[(l++) - 1]);
      if (r & 1) vr = f(dat[(--r) - 1], vr);
    }
    return f(vector<long long>, vr);
  }
};
int main() {
  int a, b;
  if (a & b & 1)
    cout << "Odd" << endl;
  else
    cout << "Even" << endl;
}
