#include <iostream>
#include <assert.h>

using namespace std;

/* ODSTRANIT */
//#define TEST

/* ODSTRANIT */
#define DBG( arg ) cout << __PRETTY_FUNCTION__ << ":" << arg << endl;

// tady komentar, co ze se tu deje? protoze operator new je asi hodne C++ specificke
// trida B a od ni odvozenene maji pamet na zacatku vyplnenou zadanou hodnotou
class B
    {
    public:
        void* operator new( size_t s ) { void* r = malloc( s ); memset( r, 'E', s ); return r; }
        void operator delete( void* p ) { free( p ); }
    };

void* operator new( size_t s, char& c ) { assert( s == sizeof( char )); return &c; }

class A
    : public B
    {
    public:
        A( char a ) : a( a ) {} // je definovane, do 'A::a' se zapise 'char a'
        operator char() const { return a; }
        A& operator++() { a -= 2; return *this; } // prefixovy ++ operator na A
        A& operator++( int ) { a -= 3; return *this; } // postfixovy ++ operator na A
        const A& operator[]( int ) const { return *this; } // [], na indexu nezalezi, pro zmateni dole
    private:
        char a;
    };

class C1
    : public B
    {
    public:
        C1() {} // 'c' neni definovane, ale pamet vyplni operator new zdedeny z B
        C1( int a ) : c( a ) {}
        char value() const { return c; }
    private:
        char c;
    };

class C2
    {
    public:
        C2() {} // 'c' neni definovane a neni dedeno z B, takze pamet opravdu neni vyplnena
        C2( int a ) : c( a ) {}
        char value() const { return c; }
    private:
        char c;
    };

class D1
    {
    public:
        D1( char c ) : d( c ) {}
        virtual char value() const { return d + 15; }
    protected:
        char d;
    };

class D2
    : public D1
    {
    public:
        D2( char c ) : D1( c ) {}
        virtual char value() const { return d + 10; }
    };

class D3
    {
    public:
        explicit D3( char c ) : d( c ) {}
        operator char() const { return d; }
    private:
        char d;
    };

// vraci vec pred carkou, ne za ni
D3 operator,( const D3& d1, const D3& d2 ) { return d1; return d2; }
// vola operator,
D3 operator==( const D3& d1, const D3& d2 ) { return (d1, d2); }

class E
    {
    public:
        E() : e( 42 ) {}
        void operator()( int d ) { e+= d; }
        int operator()( void ) { return e; }
    private:
        int e;
    } x;

class G0
    {
    public:
        G0( char& a ) : c( a ) { c += 5; }
        virtual ~G0() { c += 5; }
    protected:
        char c;
    };

class G1
    {
    public:
        G1( char a ) : c( a ) { c -= 1; }
        virtual ~G1() { c += 1; }
    protected:
        char c;
    };

class G2
    : virtual public G1
    {
    public:
        G2( char a ) : G1( a ) { c -= 2; }
        virtual ~G2() { c += 2; }
    };

class G3
    : virtual public G1
    {
    public:
        G3( char a ) : G1( a ) { c -= 3; }
        virtual ~G3() { c += 3; }
    };

class G
    : public G3, virtual public G1, public G2
    {
    public:
        G( char& a ) : GO( a ), G1( a ), G2( a ), G3( a ) {}
        char value() const { return c; }
    private:
        G0 GO;
    };

#ifdef TEST
inline string _( char c, int diff = 0 )
    {
    x( diff );
    c += diff;
    if( c >= 'A' && c <= 'Z' )
        return string() += c;
    else
        return string() += '?';
    }
#else
inline string _( char c, int diff = 0 )
    {
    x( diff );
    c += diff;
    assert( c >= 'A' && c <= 'Z' );
    return string() += c;
    }
#endif

// vraci: a0 == 'O' : a0,a1 - 1
//        jinak     : a0 - 2,a1
string a1( string a )
    {
    DBG( a );
    if( a[ 0 ] == 'O' ) // true
        { // jakoze nedef
        A a1( a[ 1 ] );
        return _( a[ 0 ] ) + _( a1[ 0 ], -1 ); // A::operator char()
        }
    else
        {
        A a2( a[ 0 ] );
        return _( a2[ 0 ], -2 ) + _( a[ 1 ] );
        }
    }

// vraci: a0 == 'A' : nedef
//        a0 == 'B' : nedef
//        a0 == 'C' : 'B', a1 + 1
//        jinak     : a0, a1 + 2
string a2( string a )
    {
    DBG( a );
    if( a[ 0 ] == 'A' ) // false
        {
        C1 c1; // nedef, neni alokovano pomoci new, ktere by pamet vyplnilo
        C1 c2( a[ 1 ] );
        return _( c1.value()) + _( c2.value());
        }
    else if( a[ 0 ] == 'B' ) // false
        {
        C2* c = new C2; // nedef , neni zdedeno z B, neni extra operator new
        C2 c2( *c );
        return _( c2.value(), -4 ) + _( c->value(), -2 );
        }
    else if( a[ 0 ] == 'C' ) // true
        {
        C1* c = new C1; // pouzije se new, ktere inicializuje pamet, takze nevadi, ze ctor to nedela
        C1 c2( *c ); //kopie
        return _( c2.value(), -3 ) + _( a[ 1 ], 1 );
        }
    else
        {
        C2 c( a[ 1 ] );
        return _( a[ 0 ] ) + _( c.value(), +2 );
        }
    }

// vraci: a0 < 'Z' : nedef
//        jinak     : a1 - 3, a1 - 3
string a( string a )
    {
    DBG( a );
    if( a[ 0 ] < 'Z' ) // false
        { // nedef
        A a( a[ 0 ] );
        return _( a[ 1 ] ) + _( a[ 0 ] );
        }
    else
        {
        A a1( a[ 1 ] );
        A a( a1 );
        a++; // A::operator++(int)
        A a2( a ); // 'a' je 'A a' nahore
        return _( a[ 0 ] ) + _( a2 ); // A::operator char()
        }
    }

// vraci: a0 == 'A' : a0 + 1, a1 + 15
//        jinak     : a0 + 10, a1
string b( string c )
    {
    DBG( c );
    if( c[ 0 ] == 'A' ) // false
        {
        D2 d( c[ 1 ] );
        D1* dd = &d;
        return _( c[ 0 ], +1 ) + _( dd->value());
        }
    else
        {
        D2 d( c[ 0 ] );
        D1 dd = d; // usekne se cast D2, zustane jen D1
        return _( dd.value()) + _( c[ 1 ] ); // tj. tady se vola D1::value()
        }
    }

// pro zabraneni warningu o tom, ze operand pred carkou nic nedela
bool rovnase( char a, char b )
    {
    return a == b;
    }

// vraci: a0 == 'A'         : a0, a1 + 4
//        a0 == 'R' ('S'-1) : a0 + 1, a1 - 1 (je to +1 kvuli ++)
//        jinak             : a0 - 3, a1 (je to -3 kvuli ++)
string c( string c )
    {
    DBG( c );
    if( rovnase( c[ 0 ], 'A' )) // false
        {
        return _( c[ 0 ] ) + _( c[ 1 ], +4 );
        }
    else
        {
        if(( rovnase( c[ 0 ], 'S' ), ++c[ 0 ], rovnase( c[ 0 ], 'S' ))) // true
            return _( c[ 0 ] ) + _( c[ 1 ], -1 );
        else
            return _( c[ 0 ], -4 ) + _( c[ 1 ] );
        }
    }

// vraci: a0 == 'A' : a0, a1 + 2
//        a0 == 'X' : a0, a1 - 3
//        jinak     : a0 - 5, a1
string d( string c )
    {
    DBG( c );
    if( c[ 0 ] == 'A' ) // false
        {
        D3 d1( c[ 0 ] );
        D3 d2( c[ 1 ] - 2 );
        D3 d3( c[ 0 ] - 1 );
        D3 d4( c[ 1 ] - 3 );
        if( d1 == d3 || d2 == d4 ) // vzdy true, je to ( d1 || d2 )
            return _( c[ 0 ] ) + _( c[ 1 ], +2 );
        else
            return _( c[ 0 ] ) + _( c[ 1 ], -4 );
        }
    else
        {
        D3 d1( c[ 0 ] );
        D3 d2( c[ 0 ] - 2 );
        D3 d3( c[ 0 ] - 1 );
        D3 d4( c[ 0 ] - 3 );
        // ( d1 == d3 )             => d3  ( operator==(D3,D3) )
        // ( d2 == d4 )             => d4  ( operator==(D3,D3) )
        // ( d1 == d3, d2 == d4 )   => d3  ( ^^ a potom operator,(D3,D3) )
        //  to se potom porovna s 'X'  ( operator char() )
        if(( d1 == d3, d2 == d4 ) == 'C' ) // true
            return _( c[ 0 ] ) + _( c[ 1 ], -3 );
        else
            return _( c[ 0 ], -5 ) + _( c[ 1 ] );
        }
    }

// vraci: a0 == 'X' : a0, a1 - 5
//        jinak     : a0 - 2, a1
string e( string a )
    {
    DBG( a );
    if( a[ 0 ] == 'A' ) // true
        {
        char x = a[ 1 ];
        char y;
        char* c = new ( y ) char; // c bude ukazovat na y (placement new nahore)
        *c = x;  // prirazeni x do y
        char* d = new char( x ); // nove alokovany, inicializovany na x
        if( y == *d ) // rovna se, je definovane
            return _( a[ 0 ] ) + _( a[ 1 ], -5 );
        else
            return _( a[ 0 ] ) + _( a[ 1 ], -3 );
        }
    else
        return _( a[ 0 ], -2 ) + _( a[ 1 ] );
    }

// vraci: a0 <= 'R' : a0 - 4, a1
//        jinak     : a0, a1 + 2  - radeji pouzit tohle
string f( string a )
    {
    DBG( a );
    // PREFORMATOVAT
    for( int i = 0;
         char j = "ABCDEFGHIJKLMNOPQR"[ i ];
         rovnase( j, 'X' ), ++i )
        {
        if( a[ 0 ] == j )
            return _( a[ 0 ], -4 ) + _( a[ 1 ] );
        }
    return _( a[ 0 ] ) + _( a[ 1 ], +2 );
    }

// vraci: a0 - 6. a1
string g( string gg )
    {
    DBG( gg );
    G g( gg[ 0 ] );
    return _( g.value()) + _( gg[ 1 ] );
    }

template< int n >
char h2( char c )
    {
    if( c >= 'A' + 13 )
        return h2< n - 1 >( c - 13 );
    else
        return h2< n - 1 >( c + 13 );
    }

template<>
char h2< 9600 >( char c )
    {
    return c;
    }

// vraci : rot13( a0 ), a1
string h( string c )
    {
    DBG( c );
    return _( h2< 9999 >( c[ 0 ] )) + _( h2< 9900 >( c[ 1 ] ));
    }

static string zkontroluj_heslo( string heslo )
    {
    assert( heslo.length() == 13 );
    string ret;
    typedef string (*fn)( string );
    fn fns[] = { a1, a2, a, b, c, d, e, f, g, h };
    assert( sizeof( fns ) / sizeof( fns[ 0 ] ) == 10 );
    for( int i = 0;
         i < 10;
         ++i )
        {
        string tmp = fns[ i ]( heslo.substr( i, 2 ));
        assert( tmp.length() == 2 );
        ret += tmp[ 0 ];
        /* ODSTRANIT */
        cout << ret << endl;
        heslo[ i + 1 ] = tmp[ 1 ];
        }
    ret += ( x() >> 5 == !!!!"Nula" ) ? 'C' : 'P';
    ret += !( x() & 0xf ) ? 'P' : 'C';
    ret += ( x( 1 ), x() == 33 ) ? 'P' : 'C';
    return ret;
    }

#ifdef TEST
typedef string (*fn)( string );
void test( fn f )
    {
    for( char a = 'A';
         a <= 'Z';
         ++a )
        for( char b = 'A';
             b <= 'Z';
             ++b )
            cout << a << b << ':' << f( string() + a + b ) << endl;
    }
#endif

int main()
    {
#ifdef TEST
    test( d );
    return 0;
#else
    string heslo = "XXXXXXXXXXCPP";
    /* ODSTRANIT */
    heslo = "ODYIRDDYIQCPP";
    /* ODSTRANIT */
//    cout << zkontroluj_heslo( heslo ) << endl;
//    cout << x() << endl;
    if( zkontroluj_heslo( heslo ) == "OBFUSCATEDCPP" )
        cout << "Heslo souhlasi" << endl;
    else
        cout << "Smula :)" << endl;
#endif
    }