#include <bits/stdc++.h>
// #include <atcoder/all>

#define TRUE true

/**/
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
/**/

using namespace std;

using ll = long long;
using ld = long double;
using pint = pair<int, int>;
using pll = pair<long long, long long>;
template <class T>
using vec = vector<T>;
template <class T>
using vec2 = vector<vec<T>>;
template <class T>
using vec3 = vector<vec2<T>>;
template <class T>
using vec4 = vector<vec3<T>>;

constexpr int INF = numeric_limits<int>::max();
constexpr ll INFL = numeric_limits<ll>::max();
constexpr ll MOD = 1000000007; // 10^9+7

namespace HitsujiLibrary
{

#define all(x) x.begin(), x.end()

#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (ll i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrep1(i, n) for (ll i = (n); i > 0; --i)
#define range(i, a, b) for (ll i = (a), i##_len = (b); i < i##_len; ++i)
#define rrange(i, a, b) for (ll i = (b)-1, i##_len = (a); i >= i##_len; --i)

#ifdef DEBUG_BUILD
#define debug(x) debugl(string(#x) + " : ", (x))
#define debugtab(tab, x) debugl(string((tab), '\t') + string(#x) + " : ", (x))
    template <class T>
    void debugl(string text, T value)
    {
        cerr << text << value << endl;
    }
#else
#define debug(x)
#define debugtab(tab, x)
#define debugl(text, value)
#endif

    template <class T1, class T2>
    ostream &operator<<(ostream &os, const pair<T1, T2> &data)
    {
        os << "(" << data.first << ", " << data.second << ")";
        return os;
    }

    template <class T>
    ostream &operator<<(ostream &os, const vector<T> &data)
    {
        if (data.size() == 0)
        {
            os << "{ }";
            return os;
        }
        os << "{";
        for (size_t i = 0; i < data.size() - 1; ++i)
        {
            os << data[i] << ", ";
        }
        os << data[data.size() - 1] << "}";
        return os;
    }

    template <class T>
    ostream &operator<<(ostream &os, const set<T> &data)
    {
        auto dataItr = data.begin();
        if (dataItr == data.end())
        {
            os << "{ }";
            return os;
        }

        os << "{" << *dataItr;
        ++dataItr;
        for (; dataItr != data.end(); ++dataItr)
        {
            os << ", " << *dataItr;
        }
        os << "}";
        return os;
    }

    template <class Key, class T>
    ostream &operator<<(ostream &os, const map<Key, T> &data)
    {
        auto dataItr = data.begin();
        if (dataItr == data.end())
        {
            os << "{ }";
            return os;
        }
        os << "{" << dataItr->first << " : " << dataItr->second;
        ++dataItr;
        for (; dataItr != data.end(); ++dataItr)
        {
            os << ", " << dataItr->first << " : " << dataItr->second;
        }
        os << "}";
        return os;
    }

    /*****/

    template <class T>
    bool chmax(T &a, const T b)
    {
        if (a < b)
        {
            a = b;
            return true;
        }
        return false;
    }

    template <class T>
    bool chmin(T &a, const T b)
    {
        if (a > b)
        {
            a = b;
            return true;
        }
        return false;
    }

    template <class T1, class T2>
    auto divup(const T1 a, const T2 b) { return (a + (b - 1)) / b; }

    template <class T>
    bool cmp_2nd(pair<T, T> a, pair<T, T> b)
    {
        if (a.second != b.second)
        {
            return a.second < b.second;
        }
        return a.first < b.first;
    }

    ll pow(ll x, ll n, const ll &p)
    {
        ll ret = 1;
        while (n > 0)
        {
            if (n & 1)
            {
                (ret *= x) %= p;
            }
            (x *= x) %= p;
            n >>= 1;
        }
        return ret;
    }

    template <class T>
    T modinv(T a, const T &p)
    {
        T b = p, u = 1, v = 0;
        while (b)
        {
            T t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        u %= p;
        if (u < 0)
        {
            u += p;
        }
        return u;
    }
} // namespace HitsujiLibrary

using namespace HitsujiLibrary;

/*****/

bool score(string s)
{
    // debug(s);

    int count = 0;
    if (s == "Yes")
    {
        count++;
    }

    if (s[0] == 'Y')
    {
        count++;
    }

    if (s.size() == 3)
    {
        count++;
    }

    // debugtab(1, string({'"', (char)(s[0] + s[1] + s[2]), '"'}));
    if ((char)(s[0] + s[1] + s[2]) == '1')
    {
        count++;
    }

    char t = 0;
    rep(i, s.size())
    {
        t ^= s[i];
    }
    // debugtab(1, string({'"', (char)(t), '"'}));
    if (t == 'O')
    {
        count++;
    }

    // debugtab(1, count);

    return count == 4;
}

void Main()
{
    vector<char> al;
    for (char ch = 'a'; ch <= 'z'; ++ch)
    {
        al.emplace_back(ch);
    }
    for (char ch = 'A'; ch <= 'Z'; ++ch)
    {
        al.emplace_back(ch);
    }

    char a = 'Y';
    for (char b : al)
    {
        for (char c : al)
        {
            if (score(string({a, b, c})))
            {
                cout << string({a, b, c}) << endl;
                return;
            }
        }
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout << std::fixed << std::setprecision(10);
    Main();
    std::cerr << flush;
    std::cout << flush;
    return 0;
}