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

using namespace std;

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 ) {} 
        operator char() const { return a; }
        A& operator++() { a -= 2; return *this; } 
        A& operator++( int ) { a -= 3; return *this; } 
        const A& operator[]( int ) const { return *this; } 
    private:
        char a;
    };

class C1
    : public B
    {
    public:
        C1() {} 
        C1( int a ) : c( a ) {}
        char value() const { return c; }
    private:
        char c;
    };

class C2
    {
    public:
        C2() {} 
        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;
    };

D3 operator,( const D3& d1, const D3& d2 ) { return d1; return d2; }
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;
    };

inline string _( char c, int diff = 0 )
    {
    x( diff );
    c += diff;
    assert( c >= 'A' && c <= 'Z' );
    return string() += c;
    }

string a1( string a )
    {
    if( a[ 0 ] == 'O' ) 
        { 
        A a1( a[ 1 ] );
        return _( a[ 0 ] ) + _( a1[ 0 ], -1 ); 
        }
    else
        {
        A a2( a[ 0 ] );
        return _( a2[ 0 ], -2 ) + _( a[ 1 ] );
        }
    }

string a2( string a )
    {
    if( a[ 0 ] == 'A' ) 
        {
        C1 c1; 
        C1 c2( a[ 1 ] );
        return _( c1.value()) + _( c2.value());
        }
    else if( a[ 0 ] == 'B' ) 
        {
        C2* c = new C2; 
        C2 c2( *c );
        return _( c2.value(), -4 ) + _( c->value(), -2 );
        }
    else if( a[ 0 ] == 'C' ) 
        {
        C1* c = new C1; 
        C1 c2( *c ); 
        return _( c2.value(), -3 ) + _( a[ 1 ], 1 );
        }
    else
        {
        C2 c( a[ 1 ] );
        return _( a[ 0 ] ) + _( c.value(), +2 );
        }
    }

string a( string a )
    {
    if( a[ 0 ] < 'Z' ) 
        { 
        A a( a[ 0 ] );
        return _( a[ 1 ] ) + _( a[ 0 ] );
        }
    else
        {
        A a1( a[ 1 ] );
        A a( a1 );
        a++; 
        A a2( a ); 
        return _( a[ 0 ] ) + _( a2 ); 
        }
    }

string b( string c )
    {
    if( c[ 0 ] == 'A' ) 
        {
        D2 d( c[ 1 ] );
        D1* dd = &d;
        return _( c[ 0 ], +1 ) + _( dd->value());
        }
    else
        {
        D2 d( c[ 0 ] );
        D1 dd = d; 
        return _( dd.value()) + _( c[ 1 ] ); 
        }
    }

bool rovnase( char a, char b )
    {
    return a == b;
    }

string c( string c )
    {
    if( rovnase( c[ 0 ], 'A' )) 
        {
        return _( c[ 0 ] ) + _( c[ 1 ], +4 );
        }
    else
        {
        if(( rovnase( c[ 0 ], 'S' ), ++c[ 0 ], rovnase( c[ 0 ], 'S' ))) 
            return _( c[ 0 ] ) + _( c[ 1 ], -1 );
        else
            return _( c[ 0 ], -4 ) + _( c[ 1 ] );
        }
    }

string d( string c )
    {
    if( c[ 0 ] == 'A' ) 
        {
        D3 d1( c[ 0 ] );
        D3 d2( c[ 1 ] - 2 );
        D3 d3( c[ 0 ] - 1 );
        D3 d4( c[ 1 ] - 3 );
        if( d1 == d3 || d2 == d4 ) 
            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 );
        if(( d1 == d3, d2 == d4 ) == 'C' ) 
            return _( c[ 0 ] ) + _( c[ 1 ], -3 );
        else
            return _( c[ 0 ], -5 ) + _( c[ 1 ] );
        }
    }

string e( string a )
    {
    if( a[ 0 ] == 'A' ) 
        {
        char x = a[ 1 ];
        char y;
        char* c = new ( y ) char; 
        *c = x;  
        char* d = new char( x ); 
        if( y == *d ) 
            return _( a[ 0 ] ) + _( a[ 1 ], -5 );
        else
            return _( a[ 0 ] ) + _( a[ 1 ], -3 );
        }
    else
        return _( a[ 0 ], -2 ) + _( a[ 1 ] );
    }

string f( string a )
    {
    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 );
    }

string g( string 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;
    }

string h( string 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 ];
        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;
    }

int main()
    {
    string heslo = "XXXXXXXXXXCPP";
    if( zkontroluj_heslo( heslo ) == "OBFUSCATEDCPP" )
        cout << "Heslo souhlasi" << endl;
    else
        cout << "Smula :)" << endl;
    }