#include <iostream>
#include <string>
#include <Windows.h>


#include "poly_str.h"


struct Entity
{

    int weapon_ammo;
    int team;
    int hp;
    int weapon_id;
    DWORD dwBase;
    int id;

};




void  function( int a, int b, std::string IZSHDNHKOH, char HKKPHYPSHX, std::string JQXPTNTHUG, char UGLVKWAFWE )
{
    std::cout << osharp::constexprs::str_obf( "a : " ).c_str( ) << a << osharp::constexprs::str_obf( " b : " ).c_str( ) << b << std::endl;
    volatile char UWHMPZJVUX = 'D';
    volatile int EIDZHBWDYC = 1655;
    volatile int XYNGWXRZLU = 6639;
    volatile int XTTBHNZJHQ = 2573;
    volatile char XFPDMZKSSD = 'P';



    std::cout << osharp::constexprs::str_obf( "random string: " ).c_str( ) << IZSHDNHKOH << std::endl;
    volatile char DYXGESJQVC = 'O';
    volatile int VWKCVWGRZI = 6638;
    volatile int NNMKZOUDBP = 1639;
    volatile char CCDYXXBDAV = 'R';
    volatile int ZPWGJAMUHO = 7142;
    volatile char FZRGHKGFRW = 'A';
    volatile std::string SIUBGNHSVJ = "JRNUBDJGNKMSXFUVPPMLDOENAGKOTGA";
    volatile std::string VPIPUQEBIP = "IGPWWLSSCJYHVNZTVTVMGJRWIXFBZKKCNB";




    if ( true )
    {
        for ( auto i = 0; i < 2248 % 500; ++i )
        {
            volatile auto SZWTTRRILF = std::string( "QWAWGTYMQUCOCZUSHKKZIAVYFOPTEVOFXJLYQ" );
            volatile auto UBXGJAPXMR = 'F' - 'O' - 'X' - 'W';
            volatile auto ZGTLYOMMLT = 'P' - UBXGJAPXMR - 'U' + 'Q' + 'D' + 'P' + 'N' - 'D' - 'T';
            volatile auto QWTPTSAQCQ = 949 * 8330 / 4479 + 9894 * 7812;
            volatile auto WTSHPNQTRU = QWTPTSAQCQ | 718 / 6014;
            volatile auto VONXVHDVLW = QWTPTSAQCQ * QWTPTSAQCQ * QWTPTSAQCQ | 7673;
            volatile auto GWGYQUKMPH = std::string( "VKBQLXMZRNXSGCTIMYFQXNMOMNZKVCAIDQA" ) + std::string( "QDGFDWXPIYMDYYBEOMOPQCGWSSQBHSPGAVIHPWXM" ) + std::string( "TWCOXJNKGVIQIGDCPUPSPCJPKRWCLZO" ) + std::string( "KSBGSMFBSWNURNMDFMKZHHMEDU" ) + std::string( "KDQFXVZYKUPHQESZNYCFXDYLWFIMFSU" );
            volatile auto UJUTJMNFSZ = std::string( "DPJRZANBZKKIWHETIFZVXHEPRKQVNEHUPWG" );
            volatile auto QRDJYPKSFO = std::string( "DBDYQTBNWOBIINLFJTOTRLSLMBFTFDLZAOA" ) + std::string( "YYKXCAKLVRISLONIHTDBHTNJSNNENUEQOSCHIIAKOP" );
            volatile auto UKRXXPNYVL = GWGYQUKMPH + std::string( "BQRFRYRVGITDGKGLQZIWVZLLNIQVGVFBJHOHMRPQNVLKOU" ) + std::string( "RIHVPLCRUZVZZZKRJANBXTSTYG" ) + std::string( "FAHWZRBWAHXQLBODHYQOWJWEYGTJXSZDIRUMTATA" ) + std::string( "PUVWDDYTXRZIHUITHCKHF" ) + std::string( "YNOWXIQCZDZCXYFTJXVNRWZWATNZCQIFZOJGUXJTUE" ) + UJUTJMNFSZ + std::string( "NRWEUQZIUTDIPZZMNBTMRM" );
            volatile auto WBAXQONNHT = 'Z';
            volatile auto PSOKASNRYP = VONXVHDVLW + 703 / 5147 / 8591;
            volatile auto QGZTBDOCUT = 8119 / WTSHPNQTRU | 3597 | 971 - 2081 - 1262 + 9041 * 5525;
            volatile auto ELCRDQRHRE = VONXVHDVLW - WTSHPNQTRU - 1648 | 9689 | 5988 | 3612 + 4353 | 5598;
            volatile auto STNBXYBWNU = 1239 * 8781 * 5303 - 4305 * 7656 | VONXVHDVLW | 4089;
            volatile auto WHLHCUTEPZ = std::string( "SSKRVWRCZWKVDDIUXRGSOITPMLOAPTQXNWJGQHFXIIE" ) + std::string( "GKZUEKIRMGGNIHUCEPMJJFEMAVECUYBT" );
        }
        volatile auto HVCVPRVYAC = std::string( "CPTVBTPJVGTNQDGXIEPTRIPAAWWZTDDFEWCCA" ) + std::string( "YOJHJOXUZTUFXPQRDOIUAEWIXWSHLMN" ) + std::string( "DHFBWMUFZXPMIUSBJMWPINFSQKOKX" ) + std::string( "MFMQMCDGNTMJUJZQBMLLXKISEXR" );
        volatile auto XOMPDDAPGO = 3311 / 1674 + 8715;
        volatile auto EXHAGGDRET = 6012 - 2098 * 390 * 320 + 6357;
        volatile auto XYHKCNNCTC = 'I' - 'Q' + 'G' - 'K';
    }
    volatile auto VZNOPXTRTO = std::string( "SHGATWXPTJNSJWJWUXZTVLCPCSBKHCEQBRAG" ) + std::string( "AODKVZTHEQYBVMHQEWQRVCFXVGIOX" ) + std::string( "YTBZXAXYYXEWFWNXIGOPQEK" ); for ( auto i = 0; i < 289 % 500; ++i )
    {
        volatile auto VIJPZPZZGF = 3746 * 6034 - 182 | 1489;
        volatile auto PIMMZFDXVJ = std::string( "BHCLGLTGTRWZTHIUBFTF" ) + std::string( "LDYOKEOKDPVAQGVXRSAXXVDDYERCWJBTCANQJTJXRJCID" ) + VZNOPXTRTO + std::string( "NMOTNCXPTENYIDGOTUARXETERP" ) + std::string( "UAJSUDETCXLKXFUYIISKCXJMNWNYU" ) + std::string( "ZYMVARALUEWBLKGXRXEXQGZYEJQMFVRDYCKDKN" );
        for ( auto i = 0; i < 41 % 500; ++i )
        {
            volatile auto SYORQBNGZN = std::string( "PPFIXPHPPTTYHAWNZFLIHMCRBPX" ) + std::string( "AWJBQSRIXJJSASDYDMOHHRRQO" ) + std::string( "LMZJHAGPIBYOXWOMSXJFTMZPMXVOWSAHRARZOXARKAGQERN" ) + VZNOPXTRTO + VZNOPXTRTO + std::string( "AQXXEOYVWRUSGILVKQHWLYFLVSMEARMSHQPNT" );
            volatile auto CMFKLMSEYC = std::string( "MTKTNXNHUZDFVSIAYLHRRPGYXFWNZLIHDMVSE" );
            volatile auto MXPCYFEIVY = std::string( "XJMFINIHUZLPUYKDCFVTFSRW" ) + std::string( "GUDFCGMNROBMVZTUNSZFSPRDKXKBHKQJYPXHBQRYFDEZ" ) + std::string( "QDAVFVLFHXROFCMTXBAAPK" );
            volatile auto GNCLWJYDNG = std::string( "YGRNQOQWTOIGDNJZBRBSNULDNMTRRYELNPMNVS" ) + std::string( "UQQKCEUNADUZEUJXTNBVEJWPHKEQRJBOQYENUCMIS" ) + std::string( "DFOLUBDRZEWQCGIFQVCQASCWQEYVNJFDYDKLKSTTZVJOLBP" );
            volatile auto EPLUXKCSUQ = std::string( "TQSJQOGXHMDDRAOIFCOQKKHCNTVNDZARYPQXSG" ) + std::string( "JTZCBGIJQVXTTTIMLECKQPYFPEMMEOMEVSUFAPWIHOCK" );
            volatile auto EPQDWLPDTU = CMFKLMSEYC + std::string( "RZQLXQHRIEQTNLYAVCKJDCATNVFPAPDNRJKHSFI" ) + std::string( "JOHNPZXYBKRRSACCEARIPTNNNWMVGDKYXBUZ" ) + std::string( "UEOTAUZPAUASMBRYZSURGDTIFJNHNBHOJZB" ) + CMFKLMSEYC + std::string( "LMEVGRLFORGRCYNLJNAQJIURPBEEM" ) + std::string( "PJCGWKCZBKTISZYCRMGEMHSLDLZWIRA" );
            volatile auto AAGNVEZEDC = 'C' + 'Y';
            volatile auto BFHDQBYHGQ = 'T' + 'E' - 'G' + AAGNVEZEDC - 'C';
            volatile auto TJGZWXWVCZ = AAGNVEZEDC - AAGNVEZEDC + AAGNVEZEDC - 'I' + 'R' - AAGNVEZEDC - 'G' - 'H';
            volatile auto KDTNMYHIBT = std::string( "BJCSLBXNEDUSMOMEZMYILDONWGZ" );
        }
        volatile auto OPXYQWPFCM = 9371 / 1211;
        volatile auto HJHVWDARPU = std::string( "AQGVHPNXYVDEMJNVDBLB" );
        volatile auto GRMGRZVSUY = VZNOPXTRTO + std::string( "QNWIJZCOTJZHTGIUTOIXDIYLPMJBRSXXM" );
        volatile auto XAMYAOPWFA = 'Q' + 'J' + 'T' - 'N';
        volatile auto WMPWWBTMTP = 4173 + 4802;
        volatile auto TZQLLOHDCQ = 8925 | 5539 - OPXYQWPFCM | OPXYQWPFCM - VIJPZPZZGF / VIJPZPZZGF * 2862;
    }
    volatile auto USXRZHIZEY = 'W';

    // add_junk
    volatile char JQIKSXASTJ = 'W';
    volatile char IUDMUWCKMI = 'W';
    volatile char JBYIPQWWSQ = 'Y';
    volatile std::string RUFWZHFYMI = "MVGJAXOXBTUAQZSDDNZWRWMVAQGKECYBBKLNIHVZ";
    volatile int TWXWTOWHDC = 4209;
    volatile char ZPILJJRDSZ = 'V';
    volatile std::string GNFVWRASYZ = "YGBKDAZNOPKWEXXLIABXBDUIIBIGSNTBPUMC";
    volatile int SZIFJWRBYY = TWXWTOWHDC - TWXWTOWHDC;
    TWXWTOWHDC = TWXWTOWHDC + SZIFJWRBYY;


    // Swapping blocks
    auto x = 8188;
    auto y = 228;

    if ( x == 5 )
    {
        std::cout << osharp::constexprs::str_obf( "x == 5\n" ).c_str( );
        volatile int MVBENHRQPE = 9718;
        volatile int GOEONLRODC = 6323;
        volatile std::string OFTWAHLAHK = "FTDSCSEOWAIQFUXXFJWFKEJQINVQ";
        volatile int TYSWGYUKSO = 8287;
        volatile std::string OTRFOOCDJF = "LFXAKNKPXNGDBPUYVCNMVAGVLRKTZSNXNHHQJXJX";
        volatile int ZYKIQQQUPG = 227;


    }


    if ( y == 7 )
    {
        std::cout << osharp::constexprs::str_obf( "y == 7\n" ).c_str( );
        volatile std::string WKZCPTCQPE = "IPUHDPXTQEVCVNVBUZJM";
        volatile char BUKXRGHQUR = 'J';
        volatile std::string KZAVIQAIHG = "AHDOUSHRGSOHVKKMIPDVNMILNUFMJJDFVFKPN";
        volatile std::string NXNZDCVREL = "DRSEKBOZRAZMUIWOJMQZUZQCFINJGPWQUOFSKBLDVQVQNLS";
        volatile std::string GNMFOLDEAQ = "BOFTCEJRGCEEIBMDEDZPTQVCSDRBJLBRTCJPQWTMETLPCIED";
        volatile int HZBABELTCA = 9554;
        volatile char HIVAMKFRWN = 'H';
        volatile char NKAEFAKYNZ = 'B';
        volatile char AQSXYWOVUZ = 'W';


    }

}

void main( )
{
    function( 10, 15, std::string( "EGNBQAZHGJAWSITAYMONOONQLMZCUHUIDCSRIM" ), 'R', std::string( "AWNYORSPQBRMGUNZJGCSGJKO" ), 'U' );
    volatile int GTWAQAQOIY = 3333;
    volatile char CGMUYWQMZM = 'Y';
    volatile char OONCFREZJZ = 'D';
    volatile char FRQJUADRXS = 'Y';
    volatile std::string MRXFDRBTUK = "BMNIRUIBDDZPGGHSYIHOVQSPOTYWSXJSUF";


    std::cin.get( );
    volatile std::string GSMWOQVSNB = "YWZDLNWQKTYUYVMJFUGUARJLGVKAFVABMCZZTUXE";
    volatile std::string PEDIXOABHP = "GHQHMNWPCWKPTWHVVMPLWCVLMGDIHJYXFCUELSMFXIBCEOJ";
    volatile char QSFPREBEMF = 'U';
    volatile int KOISYNKRBC = 4095;
    volatile int ZKNOATGYWR = 7034;
    volatile char EIGAAQSFXG = 'V';
    volatile char AIERDSLNHB = 'P';


}

static char NETYWJTVTO( char QKKEGTPDOR, char VEGFHDTYJN )
{
    if ( true )
    {
        volatile auto WSNZMEIAFN = std::string( "YDHPHCYBENZOYEFYUMMGDJCE" ) + std::string( "NHHNIUBNLBDGLTFCFDXAPA" ) + std::string( "CSRMZEMBVRDERHEWWRFSUMNE" ) + std::string( "BNPGZLYTJZBSBWCIZKFJQENLVFTZN" ) + std::string( "VTEFZLWWZAVAATRWAEKTRYGNHBDCT" ) + std::string( "IWAMARYVHGICBNQWMQXXHUDFYIXDFUWS" ) + std::string( "MLZMQHRKJKNDOSUORUVQNJPJBBVYTDIUZZQTZVGWOKMH" ) + std::string( "DWPLOLSRFBTDOCAOWNZCCXIFEETT" ) + std::string( "KVTGFLSIAEQZHIPEFNKHJSZCXOGWWOCELVPGJQCT" );
        for ( auto i = 0; i < 1220 % 500; ++i )
        {
            volatile auto WQJRFWLLBL = std::string( "DQCFIHEYVYBHABGDTVSSOPXRMTUBS" ) + WSNZMEIAFN + std::string( "QLYHBRYRSCTOSKSOMDGPATUXRHVSPNA" ) + std::string( "JJWGWIQSOPBJWQBQUVGBECAPEJRTZDEITELOV" ) + std::string( "UWFFAEKGJGBNQWSKKSQSFMVTXWBIQVRA" );
            volatile auto DXZHOTEEOY = WSNZMEIAFN + std::string( "RORZXEKEOOITMMEZTQWBDWBLBNNHHLATH" ) + std::string( "SBHXRJVUCIVMGXJQDXDNOMWFSIMSOIJFASJMFJPBFZ" ) + WSNZMEIAFN + std::string( "EBEIXDGTYQMOOWLTIBIPGPUSYDE" );
            volatile auto RMNCIEEHEB = 'Z' + 'M' - 'I' - 'K' + 'H';
            volatile auto REJHFILMPB = std::string( "CLCVLDFMTJMUIPNNQXAEBKACEEAMLBCK" ) + std::string( "UUEUPIQYYYJRLARHDTASHCHFCAZQYWJVIKHJAG" ) + std::string( "BBFJISNYROJZZCPOJBSHHXWXGCQTNHZMIHUHPYBP" ) + std::string( "VAKEFHDFBTKJOWRRHHYL" ) + std::string( "WZRHXQBHVWNDRETWUNBQFZBSPEURDH" ) + DXZHOTEEOY + WQJRFWLLBL + std::string( "EUHAKGDDXYZSSVKDNOTEPRERLSKKOJYCIQQX" );
            volatile auto NVYPQGRCVV = DXZHOTEEOY + WSNZMEIAFN + std::string( "FVVRUIMBFVBHDNFPRFJDFAONOGFYW" ) + std::string( "PFBWCKYXWBSBRMDFGIDOCNFEHMIXRU" );
        }
    }

    for ( auto i = 0; i < 4808 % 500; ++i )
    {
        volatile auto EGLVGBAWOQ = 'X';
        volatile auto MKVWNVTBQV = std::string( "MFJIVHBLQWZYNQWYJZSH" ) + std::string( "MNMRRXPSYBZNAATYYESWJCJVIQTOSGAJUZMLBYFBUHUFFR" );
        volatile auto EDVJZOKEQJ = 6562 + 1022;
        volatile auto LCHKPEXTGC = std::string( "BUGZIIWZZGJWGXGTNIZZXRSUSCYOQYCBZKYS" );
        volatile auto HCRKTDONVC = EGLVGBAWOQ - EGLVGBAWOQ + 'S' + EGLVGBAWOQ - EGLVGBAWOQ - 'Y';
        volatile auto PWQSWOOSUH = EGLVGBAWOQ + EGLVGBAWOQ - 'J' + 'K';
        volatile auto HQRZOQYPYR = std::string( "VMAAOARHBXJKRCWJWZQHR" ) + std::string( "LBNVKEAEAYDMCUWWMKATEJ" );
        volatile auto OSSIEREJHZ = std::string( "OKWYIXDGQPKKMEPTUNPVOBEAZJSR" ) + std::string( "HBDDRGKGOKXANPTNGWZYELYZHQNUQFVMNBOM" ) + std::string( "YADBIAJVDDWBTPPJPKMLBGPFOGYSJ" ) + HQRZOQYPYR + HQRZOQYPYR + std::string( "UGRLYMBBQMCXXRNSZHWFZTIWVBHHOVPTXCPZEEDGDLBGG" ) + std::string( "YUPWETNVWJZVBNOUEPCNR" );
    }

    for ( auto i = 0; i < 3697 % 500; ++i )
    {
        volatile auto BJYGJXXLOY = 5999 - 5077;
        volatile auto TSBJDXUUXK = 'U' + 'S' + 'T' + 'O' - 'U' + 'Z' + 'E' - 'O';
        volatile auto HYPJPKDEBI = std::string( "XQBEBVERHLHHPPUEXNNIUTAMQYDPSDFYOULEDOVURQHOAR" );
        volatile auto MGBNUCDQON = 7103 | BJYGJXXLOY * 5549 | BJYGJXXLOY | 8127 + 9210 + 3461;
        if ( HYPJPKDEBI == std::string( "KKLCGHKFVPDSCPVLQBMUBROHAAVZENAPVCWYWFDZHTB" ) )
        {
            volatile auto VJXERKNNQT = HYPJPKDEBI + std::string( "FCLRQPUUHZAQQVTIFHUOJDXCCYYQEGJAHDOM" ) + std::string( "SGRHSAEBFIOSREQBPZJMHHOYOFCBMG" ) + HYPJPKDEBI + std::string( "AXHRPAADICLSTSNYCOZEYPBHSNNRCNUABFOHVKXFD" ) + std::string( "HHTLVAZCMJAUILQNEFCSRTBMUOUMREWTRVSULDLULUSULZFB" );
            volatile auto PFEHNFHQGF = 8624 - MGBNUCDQON + 4664 - 7828;
            volatile auto XWKNYHWXLR = std::string( "BAMFUVNJPGFNYWXMXGAPYOVCAUVPAZ" ) + HYPJPKDEBI + HYPJPKDEBI + std::string( "TKSACRKMFJFAZYIQZPKVIXDFKLBEIRRXPAVQHGMLSBVZ" ) + std::string( "GNQRPGDNRIKZCRJTDZDGCDROVLSTMXFFNZJUPVVLYHIEL" ) + std::string( "CVEOKAUCFMCHPDHDRIUUNCFYYNBFNZGFGYNZRXNGOCGE" ) + std::string( "QFPWZPOFFXBQPILUUOGKWBNMWSVYKHGXQOIMHRGZOAYNKATBC" ) + std::string( "TPVXQEZAZZMDHHWWCZBVZTWQDVUT" );
            volatile auto EQZFYFAWGB = HYPJPKDEBI + std::string( "YOUTDPLPFKAKAVRCJOIAEFAQXTQUBZYDUVLOYFOQTMYBRU" ) + std::string( "DWKYRNGMXPEKDEDASGSHYZCOLFDMQIYDRZUJ" );
            volatile auto YRPTEZVMTI = 7589;
            volatile auto BSDJUWADTP = std::string( "MJIZNTSEOVNFROBLQMKZPYDXVHCUUBGXMIHVEZ" );
            volatile auto JWGYBGSVKQ = std::string( "QJHXMPDZOMUVMIMJDIZZCUZJBNPNWM" ) + std::string( "GDPMGIHLGOTZGWJXVYAPDCMFPUBWXYKQS" ) + std::string( "GLJGOJYIRIEQJXLGLOHECHPJMDFSSJSWCKIJSPIPMIBI" ) + std::string( "WZULDFPHQINZOCNVFSSUGHBGSNYROVYWRKMSVWMGSTSASLER" ) + std::string( "HXSUJRHDPUAJGLBMOBOHIGEPFTITRXTHEWYUAX" ) + std::string( "AXZKHBTDPPIOMSATEJMGMRKNEI" ) + XWKNYHWXLR + std::string( "BWIATPOJRFCPPRTJNMGYWIMRVBSBUELLUPFPIJUPUVTKUER" );
            volatile auto JUNQBSKRER = 'E' - 'E' + 'K' - 'N' - 'Y';
            volatile auto KTGSWVSQOC = 2300 - 5584 * 8023 | 755 | 2293;
            volatile auto PZRMUHEZST = JUNQBSKRER + JUNQBSKRER - 'E';
            volatile auto WLFEUWMWBD = KTGSWVSQOC * 3545 + PFEHNFHQGF * 2353 | PFEHNFHQGF / 7718 | 8215 - 4940;
            volatile auto NAHVVPNHAJ = 3904 - 2387 * 4497 + 8120;
        }
        volatile auto QDZCVEFCPQ = 'U' + 'I' + 'W' - 'D' - TSBJDXUUXK - TSBJDXUUXK + 'P';
        volatile auto MSPOITLZIK = std::string( "IXDHPWJAAYBSFMCPECWNPIPYFPLCVCH" ) + std::string( "KOSTFGBKHXLUZIEBAKGEYQHBBWCZGPTGZSFKNV" ) + std::string( "MSALRTGRRIDBESEFVHDTOEEKJHQMWTFLNJDBFOALDWDXSS" ) + std::string( "BKCUUYDSOUODZHGRQSBGSQUJUWFWXVBWNPMQII" ) + std::string( "BQGHXLQTZYSGUTTSQKUQIHRWMRMBQGWZTBTLQGRBZPJCL" ) + std::string( "YJUGYOCSCTNSZHCJSTQTYOLYLBCPJGOHOZMGLLCLMQA" );
        volatile auto MRYOXSVTWK = 'Y' - 'V' + 'G' + 'O' + QDZCVEFCPQ - TSBJDXUUXK + 'F' - 'O';
        volatile auto SWZERSDYCP = std::string( "UEKACREAGQNWHZOZBHPIPZADEBWWLASALKXKPAFWEQRZTGDQO" ) + MSPOITLZIK + std::string( "KXCDJBCTEZHAKYYGIESMEXACGIEDAWCLBG" ) + std::string( "WXDPZJNLIMXAXBWYSIWVZEC" ) + std::string( "HALXSYPYIHONVLFKBNRDRUKXBBDEGYHLTO" ) + std::string( "MYCQNBXZUMQOVRULRKZCTGWIEQJTTLA" ) + std::string( "CHSPMDZOJLAPFCTMXSDGIMRUDBOJBAUOZMTBMBWQUWQ" ) + std::string( "PPXLLOPNJRLQSISAVVMMMVEBBRMBYNGDL" ) + std::string( "HMRUPCRSYBZTKWKTCOPWKIEREHLGJKHCOITOZRLVVOFJB" );
        volatile auto FRZQTLLZIZ = std::string( "WNJVBXKQBCNCFHOUIYOPRKFLOIDRUWDIRIYT" ) + std::string( "UCGOLVWLHXGTTTVFZFLXJVECWHPCU" ) + std::string( "NLSZIOHTLNLRUZZYDSEGUQODUCXXDOJIP" ) + std::string( "VVWWTNWSORWWPEFRJPWDDBJDPLZELY" ) + std::string( "BUZMXYHBYTMCGUMTHINSGPFOOVFYQJFVQNZPDC" ) + std::string( "SBNUJLOLYCTIKONRMSUXQFTMVVPN" ) + std::string( "OARDMHNAMEDUUKXQNIAZNWBRR" );
        volatile auto BXKJQOFWYB = 2933 - 5646;
        volatile auto GEBSMAVSRT = 5265;
        volatile auto YWOPWKHLFA = MRYOXSVTWK + 'T' - QDZCVEFCPQ - QDZCVEFCPQ - 'T' - MRYOXSVTWK + MRYOXSVTWK - 'R';
        volatile auto ERLCQWRDYG = QDZCVEFCPQ - 'V' - 'H' + 'G';
        volatile auto KTIGTBINLP = std::string( "BHTXJLJUZOYPWZHWWGADBZ" ) + std::string( "ZRZLTFSEXDDLXTJWVJOZACWUOGXJACHVAAAQXKNVLXCH" ) + std::string( "UEXMHJEUVHKWTTYKWSODZPYPBCSBBKHKGCVSNBOBTILONIB" ) + std::string( "ERCTLZAQRYGWVEMJREKCSBUBJJMIODQM" ) + std::string( "TUFQPHHAWERDWAJBNSCNHUQEVBTCEVPARVIPDVSGWQPBYGNQF" ) + std::string( "FVBPQLBSTXSAWQREOFONDWGUVLUDJLDZERRU" ) + std::string( "AUPUGALIOGTFRXJIUSWEZWPCXUB" ) + std::string( "SDGIGHSCDOODFPXPGDEMXMZGXHVSN" );
        volatile auto LMZSYQQHJV = std::string( "JGRRWRIFYLRMMGJLQJWSMLDEAIPRWRSKWBTUEVUXYUPZ" ) + KTIGTBINLP + std::string( "OHUPZUSVDZTJTZPUDCXSVRRFGVHMIGYQOI" ) + KTIGTBINLP + std::string( "NPDSSRXQPJDMFNXBCULVPRETTBTQDHCNPTVQUXWRGJ" ) + std::string( "WDVKKZQXGMIGQXMRHGEYTPFFOOCQEORLSQTPZFKYFTZXDI" );
        volatile auto XVFRLDHYPV = std::string( "YJBGMSHIRHEMYHEULJSRCZCJOJTYVURMX" ) + std::string( "FEKMTENWPJZGSSDYIMXQRPJYKPX" ) + KTIGTBINLP + KTIGTBINLP + KTIGTBINLP + std::string( "YZJJFKPQVMBDHGBQDDGPJYPWKHNBHCOXCBIVPWRPNRJW" ) + std::string( "AJMYXXNJSXDBFXGBGMRBRPSMMZPMQZIRD" );
        volatile auto CXTRAIRZGW = 'H' + 'Z' + 'C' + 'U' + 'T' - 'W' - 'I' - 'V' - 'Z';
        volatile auto QHGSMHKZNV = CXTRAIRZGW + 'F' + 'P';
        volatile auto EBBURZTFYF = 1912 / 8192 | 6649;
        volatile auto WLUBZIPETT = 7425 - 7815 - EBBURZTFYF - EBBURZTFYF | 2316 - 1039 / 7690;
    }

    volatile auto HLNJGVFHOT = 4836 | 3495 - 440 - 7777 / 5030 / 1303;
    volatile auto QMJSNXGLVP = std::string( "BVTVBKQAUCUPASKAHPZSUZXMYWHJAAHPWWHHHWCOZ" ) + std::string( "SYBXHWFCHZTVESEKCSLMKTXJTVBTNIVWVYEXFKZA" ) + std::string( "TYHZARELULPZEXAGOGESSKPXBAMLJXWDKI" ) + std::string( "SSZIFPREFUIIJXZFSCWPLOVUDQJJRMEFEAJHNCEIEZEOUN" );
    volatile auto INLIVMDWEE = std::string( "TPEOGDWFUWFVUIHISIMO" ) + std::string( "YNMVEJIYAGQBNODKYJEFHWAU" ) + QMJSNXGLVP + std::string( "HHUTGZIHYZWCMSPGCNEKSYJLRXPMEUFSIIMYDNOUH" );
    volatile auto EUTCVXGMJD = std::string( "VPAUPVCQICUZQIOUFXOPNNVG" ) + std::string( "WGKTUNLQSZKEQLVGRIRI" ) + std::string( "ANXZMVVZBENJSQIKWBHDQZGBVYSQS" ) + std::string( "RGPHBTJUKTTNJRAHVENCEGGIPXQMGWAGLQ" ) + std::string( "CLDURRGTIKZHRECXOOSMBSSGQBKITJZ" ) + QMJSNXGLVP + QMJSNXGLVP + std::string( "DQHYZZLVCMJXPCJJLIKDNHYVFIBFVOXLMLHOBCSJCYGQGF" );
    volatile auto ZFZZOJWSLS = QKKEGTPDOR + 'I' - QKKEGTPDOR - 'Y' + QKKEGTPDOR - 'A' - QKKEGTPDOR + 'C' + 'L';
    volatile auto LWFQZPAUUK = QKKEGTPDOR + 'N';
    volatile auto CVYUUKBCNP = std::string( "YHXCPPFVEKERHYKOZGHNAHTTPZLYYUZYMRXCYZGQWGHQDUYTZ" );
    volatile auto REZRNDNQDH = HLNJGVFHOT | 5724 * 6735 / 6020;
    volatile auto APZXYVSUOJ = 'R';
    volatile auto ODITAAFUXP = 'N' + 'U' - QKKEGTPDOR + QKKEGTPDOR + QKKEGTPDOR + 'Q' - 'A';
    volatile auto LZAJUTHAWP = std::string( "FBCXTJZNSCGRUDKPIGHOYVFGCQCNIMUOQNMDOISPV" ) + CVYUUKBCNP + std::string( "HSBGQHBANRSUSOJLCGLTQCXFTCH" ) + std::string( "UNUEZSARHLJZZALPEVWMOAINYI" ) + std::string( "XNTKZHEPJINHFJTVRUFHFRIEWCHNEYKFTGXJTDAAJIYAINZV" ) + CVYUUKBCNP + CVYUUKBCNP + std::string( "FYXSIVIDLLFOOFENREEPDASXOCAZAKSYWCVPVOWTGTO" );
    volatile auto KCKLUFWXQE = std::string( "RNLZEXSVTRXMOHTSILNWTNLGFSATEWSRLLSYBSOUFTUYPPK" ) + QMJSNXGLVP + QMJSNXGLVP + EUTCVXGMJD + std::string( "WWYCXFCXAJNIPBBWAJLDKPODDACENERTUZYTR" ) + std::string( "LNTEWEEHHVZWDYJWSUNQDHEFNAGODGADTHTALMXQURMW" );
    if ( LZAJUTHAWP == CVYUUKBCNP )
    {
        volatile auto JLPTGHBDDC = 6979 * 3495 / HLNJGVFHOT - 8783 + 6594;
        volatile auto STVZBYKENV = 2338 * 5004 + 5189 + 7518 - 9475;
    }

    volatile auto VHECCGUKWX = 'R' + 'K' + 'Z' - QKKEGTPDOR + 'T' + 'H';
    volatile auto BXZEPJZRVR = HLNJGVFHOT * REZRNDNQDH / REZRNDNQDH * 5622 | HLNJGVFHOT + HLNJGVFHOT | 2418 + 2525 - 8015;
    volatile auto WDGEUPUFYM = 9449;
    volatile auto ZGWXRTDSHH = HLNJGVFHOT + 8929 + HLNJGVFHOT | 7877;
    if ( VHECCGUKWX > ZFZZOJWSLS )
    {
        volatile auto YNHPJSRKJL = HLNJGVFHOT * WDGEUPUFYM / 3864 + 2701 - WDGEUPUFYM * 9074 - 5385;
        for ( auto i = 0; i < 7763 % 500; ++i )
        {
            volatile auto GCCUTEZWKC = 'C' + 'B' + 'U' + 'O' - 'F' - 'M' - 'R';
            volatile auto WXFCJSROFE = 'R';
            volatile auto IIQGADZSFG = 'C' + 'Y' - 'B' + 'K';
            volatile auto GRIHXIBQAI = std::string( "PVISHRPAYDYXHIMKQVITHSVXSPTENBOKMDEIHZBCMPXGPBZR" ) + std::string( "XLMXPOLEDEDRUFGRUOHRPCKFBTUTMGIWZJEBDARB" ) + std::string( "DIBVAHVVTSSXVGSKAEOUXFBUOVASSKHN" ) + std::string( "DQTYQQJHKINXHHGEHDDJKESXNCCRDTPBXDQYBCBBBZCVKVI" ) + std::string( "OORERSMAEQICECBHLCXMRTBOFFOJYQSA" ) + std::string( "UVJYQRBWAJTVNDYMEDBNYIXMOOYPQUOV" ) + std::string( "YRZFXZYUURMLYWJBSMFGUXHWJOQOKUZCIBOXOTSRVUBXD" ) + std::string( "KCWIIJKZRKCWIMMZTOKAV" );
            volatile auto BRIUGWLPAM = 1393 / 6172 | 6416 * HLNJGVFHOT * 776;
            volatile auto TIJVSSUTCL = 'O' + 'E' + 'R' + 'E' + 'L' + 'C' - 'D' + 'I';
        }
        volatile auto XNTSIKZHID = ZGWXRTDSHH / 3728 | 7155;
        volatile auto EFNNFILTSL = 7452;
        volatile auto VUWSLQZTML = 'L' - 'A' + 'O' + 'U' - 'Z' - 'O';
        volatile auto TTRELXQSPY = std::string( "MSZLGQISGIMEXYKVUODJULQGIYCYPQMCS" ) + std::string( "SQHKEQBHMFQACTDHOJCQVJLITUBCGYHHNSNSRRUYOEPNXENA" );
        volatile auto SJHCIEYRJP = 'D';
    }

    volatile auto LPHBNFJOYF = std::string( "KSZESGFXHWEHWHDIJUGLVZLTWUYQDZGAZNXSIPI" ) + std::string( "TNELULGFIXIOUIQDIIJKAULPSXCNMOXXXOFSWN" );
    volatile auto DGKHDEOHEZ = 'L' + QKKEGTPDOR - 'F' - 'W' - 'H' + QKKEGTPDOR + 'U';
    volatile auto BRLBUDUKKM = 'L' + 'C' - 'O';
    volatile auto IAOTYUQDPQ = BXZEPJZRVR - 9418;
    if ( ZFZZOJWSLS == 'B' )
    {
        for ( auto i = 0; i < 1418 % 500; ++i )
        {
            volatile auto WTEYLQLJGX = 'R' + ZFZZOJWSLS - 'M' + 'H' + 'M';
            volatile auto GNDLXXEMRF = 'H' - 'B' - ZFZZOJWSLS + APZXYVSUOJ - 'C' + 'T' + ZFZZOJWSLS - 'N';
            volatile auto XIACGNHCEL = 3531 * BXZEPJZRVR + 3300 / 1196;
            volatile auto HSOAQGSSKE = 7540 * 2723 + 8831 / 7106 - IAOTYUQDPQ / 228 * 8484;
            volatile auto BVTNFTFQMC = 'B' + 'Z' - 'D' - 'A' + 'T';
            volatile auto XQVJRYHEIY = std::string( "CJVCCBPCETQGMTNZCAFNQYFQGPIYQUPNKZIMDAWRHSSQQ" ) + QMJSNXGLVP + QMJSNXGLVP + QMJSNXGLVP + QMJSNXGLVP + QMJSNXGLVP + std::string( "GVCSVVOGXPETDBPUJNZESFSXXUPORXBNTQKGOHUHB" ) + std::string( "DABDFUAGZPZNQZNRIFBTRDEXZCMPSNEXCZQQ" ) + std::string( "LRFSGXGWAVDDCILOMKCLRJX" );
            volatile auto OZQBGPUZAX = CVYUUKBCNP + std::string( "NXDQHNQOWQGRQCWUKYBDC" ) + std::string( "HPKKKJZLBSDWMPNNWUNRFYRP" ) + std::string( "MKZPCSBDFVGRGLTGZDYIXUYMIGTDXZLYGAB" ) + std::string( "MFEOEHPZPRLMGVZYFFKHLGKHMAOLK" );
            volatile auto VATNYIVDJH = 8370 + 4596 / 9036 / 6734;
            volatile auto EDWQMRBZLU = QMJSNXGLVP + std::string( "SSOWESMYNKWJTXSTNBLZOKUKAHCHWFWW" ) + std::string( "ETZJBFRJOXWHYEVXQEBHNAUFBNFNVTH" ) + std::string( "ISROGJEJBMHEWEZUIOADNUPRKOYNOXYLTAR" );
        }
        volatile auto VJLSUYSOBI = 1463 * 571 | 1207 * 2838;
        volatile auto HPKKQYMJHM = 'V' + 'K' + DGKHDEOHEZ - 'E' - 'T' - 'T';
        volatile auto PEMDJFTEUD = 'L' - 'E' - 'N' + 'G' + 'P' + 'B';
        volatile auto WNWWPWOZGR = 'W' + 'O' + 'Z' + 'G' + 'B' + 'V' + 'W' + 'R';
        volatile auto PFZHVMIYBJ = 8092 + 6478 - ZGWXRTDSHH / HLNJGVFHOT / WDGEUPUFYM / 7357;
        volatile auto SMIEOILSNI = 112 - BXZEPJZRVR / 73 * 1565 | WDGEUPUFYM | 9711 + ZGWXRTDSHH / 8139 - 5697;
    }

    volatile auto AQEDMZTYBL = 5212 / 3958 + 6797 / 5285;
    if ( WDGEUPUFYM >= BXZEPJZRVR )
    {
        volatile auto NKAUKRUUDU = std::string( "LFGEFSNUYOTNLHGAWDXDKIMZTRKAZVUORZMHEHPDPV" ) + std::string( "JDTGKOHNVDTFVLUYVOOTOO" ) + std::string( "QJOYXAWCASLVNQMCEZULNUQMHAYDNWVHWGVLJX" ) + std::string( "UISXCVTCQWCTPDWEZHUASGHHOBGVPEDYLPBNPZEZSHHUKEX" ) + std::string( "APXMLTDHZBIOADUIKZNWJDVXXBOTUJ" ) + std::string( "XIPDDLKIVOMOZWUZPJEJMQNVKKAKNODMOMGMITYCIMOZAP" ) + std::string( "USTLAVGLAZMQHRVLCAACOUVTTUSHRPRCZRNBFQIRHNZP" );
        volatile auto DLATXJEGZX = BXZEPJZRVR - WDGEUPUFYM * 7681 - 2859 * 6916 * 6249 | 7547;
        volatile auto OORLHILUJI = std::string( "CWMQILPBRPZKUVSDGANVLWMCFZUXMILLGPCHRDQ" ) + std::string( "SRXEGJJLJQRPJDNEFSKLDJNWCDJXRLPHHQTUIKWX" ) + std::string( "FSOIEBCCAMUXAKITKTVVWNDLCEPITKFHED" ) + std::string( "JIXLQPYNMPSPCGALTJPHMTXHTRAEONCPINSVSXCVHUSNJZZ" );
        volatile auto OKHNLQLPRZ = std::string( "QCRXGSEGZUUKMLURRCOMWGIQBIGFRHOUIIMILIXNIO" );
        volatile auto HXFPKABYAW = 'M' + 'P' + LWFQZPAUUK + LWFQZPAUUK - 'I' - 'I' + 'X';
        if ( INLIVMDWEE == std::string( "QJGTUAZKQQFIUPYALXGAAFUE" ) )
        {
            volatile auto VOEOYXVKGH = DLATXJEGZX + ZGWXRTDSHH / 9000 + 2580 - 7087;
            volatile auto NJWTNHUHQA = 'Y' - BRLBUDUKKM - 'Y' - ODITAAFUXP - 'X' - 'U' - 'M';
            volatile auto WMPZYCFCQW = 9766 / 1519 + 9312 * 5877 * IAOTYUQDPQ * REZRNDNQDH + 5092 - 3173 * 3569;
            volatile auto DVGVLXJFWY = BRLBUDUKKM + 'B' - 'D' + 'E' - 'H' - 'J' + NJWTNHUHQA + 'K';
        }
    }

    volatile auto VUSYUQGBAK = QKKEGTPDOR - QKKEGTPDOR + BRLBUDUKKM + 'F' + 'Y' - 'M' + BRLBUDUKKM + 'W';
    if ( QMJSNXGLVP == std::string( "YCXFSOWCEEWZQGLPQBDBUWLKCSQCSVQWRZTUDETHXXTL" ) )
    {
        volatile auto JOUUEFIXBC = std::string( "TEYQSZQVLLRDMNSVNVLOMBITDFNQAFQZNA" ) + std::string( "TDCAGPMGJZSWFNMLAVFVSPLNYCZXKKZJGAJCLPUQD" );
        volatile auto HXNALQDSLG = 1545 * 549;
        if ( INLIVMDWEE == LPHBNFJOYF )
        {
            volatile auto DZZDXJNDCF = APZXYVSUOJ - 'K' + 'H';
            volatile auto NXAGKNUZBC = EUTCVXGMJD + std::string( "DMHMJHUSDYPPCGRDCMCWUPUVB" );
            volatile auto MIOALIBEQE = 'V' + 'P' - 'G';
            volatile auto ZIBJUMEMYN = 'P' - 'O';
        }
        volatile auto WRZIFDNJGR = LPHBNFJOYF + std::string( "STFNAFPOQPFSKMCFSGRYBTMTOQKCVZRN" ) + KCKLUFWXQE + JOUUEFIXBC + std::string( "QLEVUJYGLZJUNTQYRPHYCNTRICRRKAEGUDFNMSITPTHZFOIQ" );
        volatile auto VBRWDRMNRR = 3263 | 2648 - 9375 + 9166 + ZGWXRTDSHH * HXNALQDSLG - 4824 / 2571;
        volatile auto DMHQNCQCYQ = 1894 + AQEDMZTYBL | 6381;
        volatile auto SAXNKISVWA = 'R' + 'B' - ZFZZOJWSLS - 'T' + 'G' + 'N';
        volatile auto VSSCFAGBTI = ZFZZOJWSLS - 'R' - 'D';
    }

    volatile auto OFRZHMIFRV = 'I';
    volatile auto JPSFJHMKNJ = QKKEGTPDOR + QKKEGTPDOR - 'K' - QKKEGTPDOR - 'X' + 'D';
    volatile auto NBFECZYGSR = std::string( "KSBVMIUUQCOHEGQJOIPLSKXGPBARPLMPE" );
    volatile auto QPTQZHFZVV = 'I' + QKKEGTPDOR + DGKHDEOHEZ - 'U' - 'I';
    volatile auto JXSQIMBTOV = 4861 * ZGWXRTDSHH + BXZEPJZRVR * 1134;
    if ( QMJSNXGLVP == std::string( "QNQPGURYAPOEUHXSPJBOL" ) )
    {
        for ( auto i = 0; i < 2316 % 500; ++i )
        {
            volatile auto RPWFKXROVE = 1583 + 7971 | 1572 - 8832 + 4090 | 8647 * 6534;
            volatile auto QPGIMOTPUS = JXSQIMBTOV + 8452 + JXSQIMBTOV - 166 + 6554 - BXZEPJZRVR * 7117;
            volatile auto FVOVUSEICM = 3257 * RPWFKXROVE + 6408 - 6737;
            volatile auto MUPIJTNQTH = 6851 | 2737 * 989;
            volatile auto QWXUQIQRTF = 'V' - BRLBUDUKKM - 'V' - 'E' + 'V' - BRLBUDUKKM - 'P' - 'J';
            volatile auto DAAVUJISJV = 'U' + 'Z' + 'F' + LWFQZPAUUK - 'I' - 'K';
            volatile auto UJQMGEMHTH = KCKLUFWXQE + std::string( "UECAWUKRSIFRJFHHLYDBXJ" ) + KCKLUFWXQE + std::string( "HJCKHNYXPKHELXVIBWWTYWHEOAHJCMCHXSZXPKQ" ) + KCKLUFWXQE + INLIVMDWEE + KCKLUFWXQE + std::string( "SXXTRFWUBZUYZHEICBWKQZOWQOJU" );
            volatile auto FFHAFDGUZA = KCKLUFWXQE + std::string( "DZCSGRGFSDCVUPGMLGMMKMJFPNVDAZBCSPSKCPWW" ) + std::string( "PPRHRPWDTWDETBADFWVKWKQBXVUDAPRTWELMBIBUFMCA" );
            volatile auto NBLSINTYFZ = std::string( "OXJUVYORMGVDFKJZQYQBTAITYOPKNGBVTOQI" ) + INLIVMDWEE + UJQMGEMHTH + std::string( "GJDEFFAKQTAVZVLQYCPUFTRXYNEZJUDTOUWWHQRNZIFEM" );
            volatile auto LTWKZVRNRG = 4275 + 7046 + 5605 * 1668 + 4073 / 6850 - 402;
            volatile auto KQRYPMLBSO = std::string( "GRQRVLBEXGBXGDDTQZXCOEH" ) + std::string( "KUYZWLORIFFKANWLRWLOCKBP" ) + std::string( "RABQZNYJWNZLIDXTDUBASIBLIOJRTXNAUXURUVPPMRTJLRRF" ) + std::string( "DHQZAZQKIGYIEMOBOSZRXDXBSJCCRLT" ) + INLIVMDWEE + std::string( "MEETGQQMAKOHQWNTXNUUZBJZUINPRHKIVLQYNRNMXSKUNNTP" );
            volatile auto ZYCZLUFZXD = std::string( "WSUHBPIYHTZQFSUFSSJEZRKPVTTBMYNLYBKYUEFZQDWOL" ) + std::string( "HFLIWGLJGNSEIWLONKNVVWDBF" );
            volatile auto INFTEFQOSX = 'R' - 'Z' + 'A' - 'F';
            volatile auto HVVMOPCJHH = std::string( "WSFNAHCRBNEPFWFMSYNDOOZJPMQUOGAYGADXSZHPMLC" ) + std::string( "FHSWXORHDVNGIESHUTRXQDMPZYWCKCKYAHVWFWBTYFIHXDIK" );
            volatile auto DJZHCUDWYR = std::string( "PLBIFFPRDZEBQVAYOXPDOJIXJKK" ) + ZYCZLUFZXD + KCKLUFWXQE + std::string( "FKDZVXNKSSFCDYUVIBIVDXEIKBTBLMYRZEDAHIUYPQ" ) + std::string( "PIGUOUDMZGUODYUUOAHKFNMLBWGXACDKILOV" ) + std::string( "BGUJFYICWUSSNFMWCJGSKYZBGHPBVGLJMLVTITEJCLZZ" ) + std::string( "GSCYJGHPIJGCJSNJEXPYZAH" ) + std::string( "MQRGZVEJQKVKFYHTLPCMDGLXCKWFLMNMCRFXRXXUT" );
            volatile auto JKTLTKKGRN = std::string( "XPJUDJQFLYOMWBROTNTRCTJNXTQOMP" ) + std::string( "IJGIWEIMIRZTGDGWWJSBSVNWKEXADZOCOJLZHPWMG" ) + ZYCZLUFZXD + std::string( "WJXRGIJICWEWSGPHNGVSOTECTWPPCZFNJY" ) + KQRYPMLBSO + HVVMOPCJHH + std::string( "RFHYDEVXJTTGDRQMTDRPI" );
        }
        volatile auto XEOLRMYNHB = 200 * AQEDMZTYBL - IAOTYUQDPQ - 9951 + 462 | 5453 / WDGEUPUFYM * 2215 * 4407;
        volatile auto FMHISDKFLX = 8003 + 685 * 4714 / 1816 - 1172 * 3236 | JXSQIMBTOV - 2591 | 7560;
        volatile auto IPJEEECDYQ = std::string( "TQQAKFPOWSEPLOYYFKKM" ) + std::string( "SWJGMIEKMBCRNLMIQYTIZWEIWPNIDPUP" ) + KCKLUFWXQE + INLIVMDWEE + std::string( "VWHWGNPTPWDYMWCZWKZTCLTKGYBSHAYEGOAKSDNVNTMSPK" ) + std::string( "QILXLOYYSYWSGTXEGIYAVVOLMVBSCPTQHWNEKQIYUQSKU" ) + std::string( "ZKQNGWCFFKJGTTQAAGECEQZPVJFDGFGWSKKFSKOUQF" ) + std::string( "PJKARWRYZAENNIJKHPSKMYBWSWTBITULAAVBVRTR" ) + std::string( "VCLFQIOIVCQQFFTMNNIOQWAHV" );
        volatile auto ILMGWOYIOV = std::string( "YLVVRCTLNTUAAAFLLFXRIOYDGJCUY" ) + NBFECZYGSR + std::string( "OTQGFMGESQAKNROHAZNHJXLVZPCWXEUTRCONTVPLZGEYE" ) + std::string( "HVHPKKGOVGSKDBNFKBIDSNQJMMVWLXSCPWFYOZBO" );
        volatile auto YXSMZNNMZG = IAOTYUQDPQ * JXSQIMBTOV - 7588 - 8437 / IAOTYUQDPQ + 8712 + 3500 - 7703 | 2490;
        volatile auto PKRQLFWSCW = 959;
        volatile auto IOTCRKYDOQ = YXSMZNNMZG / HLNJGVFHOT + AQEDMZTYBL - 5755 * 3596 * 6033 | 1868;
        volatile auto KGIACZBZLH = std::string( "VTYUAUOOTOESOAIAEKWKBKRWKJPYMMADVQZWDASIZHJWK" ) + std::string( "BCKQEPBHNBWYBLWDRNKUAVMSRLEQOQNW" );
        volatile auto BPCEJGCIJU = std::string( "PSEFDSMMLSNTAJQUYABSHIBKPLYDSPDHEHTCLOT" ) + std::string( "LJUBIHQTQSUJTWPGPSPO" );
        volatile auto IXZPFOLHVV = 8572 * 1404;
        volatile auto FFKYNBSWTM = 'J' + 'T';
        volatile auto MDKWCRIQZQ = std::string( "GQHOZXDNTFLQNCIJXCLBKXDSBWINHFEUKSWTWWMPKRKJCI" ) + std::string( "PMCOPFOAQGUFONAPWRSNTQTUSXGJEHBGNFH" );
        volatile auto UMVJLCHKBO = 8707 * YXSMZNNMZG - WDGEUPUFYM - 7102;
        volatile auto JMRMIQBDBN = std::string( "FHYIJCQRVKEBBZTELQHYASVIQUFBOTJLWEPM" ) + std::string( "PGIRYGINMLPSOWOCBASEXJGBVVQTDKVEEZPUGBLEOQDB" );
        volatile auto ZLHYGAGWCQ = 2467 + IAOTYUQDPQ - 2758 + 8865;
        volatile auto UQXLVMAXTS = JMRMIQBDBN + std::string( "JFNYMLIIESABGUZRHIJFZGQPAIZMDGQDJMKVCAPBXOVAT" ) + std::string( "XXEMVEYBXSUKDPHSHILKQWCNKAHGJLHPGGECL" ) + std::string( "OJTKSYBUQBVXRRLKEDWKEGRHCNRAWNGSZOVCNFOI" ) + std::string( "ALXNHRMIEGAYDUCYCVJXZOOGWLEAQGLQBRGGBBOKAWJBC" );
        volatile auto DNEKAYWLXR = std::string( "KNDBBPPVVUTQSOLQOCIYTHKBOH" ) + std::string( "UZPQKXSOLSGNOYTUMDDCMUZDWXGSPDQOIXIJJDWN" ) + std::string( "VTFEZZLTMRAZICRERQKLIGQ" );
        volatile auto BYLPQKIAUV = std::string( "NYWULMMGLEXQMMFGRSAIK" ) + std::string( "WIVRIAFNSBDAKDFCBEJYZQBXLASDISUZEYPDKOIR" ) + std::string( "VURGGYGIHCFAGDVLOBRMVRDFYRZZPEZGGH" ) + LPHBNFJOYF + std::string( "PYACKZQERMHPYHSDCZTYZLEFFFFVGKQGNEKRDXWGRZS" );
        volatile auto NAHHPPYEUD = UMVJLCHKBO / HLNJGVFHOT / 1093 + 3397 / 2991 + 9113 | 8979 | 9045;
        volatile auto MQCEXPEBEK = std::string( "WPJRYZXPEOQKRDUJOFZUAXAYREXUHGEFFAFQSFTFIBDZYWJAS" ) + BPCEJGCIJU + std::string( "LFQXDQJLUMZTAAUVXBEUSOOBGBHFZEE" );
        volatile auto MRSCOMCAWE = 'R' - 'D';
        volatile auto SSJBBMXABA = BPCEJGCIJU + std::string( "BPSDMLIJJCZFSPEUZLSQUWRXEQTDJQWX" ) + std::string( "CEXOLOOMKIQFXUZWSEATFBIUCJBDUW" ) + std::string( "NOHGYXVVCAGMDAVCLCMKSNWBPOAZDON" ) + UQXLVMAXTS + std::string( "FUDPSPHRRZRFQKXWROMAVHL" ) + BPCEJGCIJU + std::string( "WXYZEPCIFAHLHFYIHXICACXZPXFGMDBRACSP" ) + std::string( "OMKFLXTOTZZKGJVWBYQLENJGLUMCTRGYYK" );
        volatile auto XQTGOYPCLW = 6738 | 3186;
        volatile auto PUEZXZYJHO = 'Z' + 'V' + 'A' - 'A' + VUSYUQGBAK + 'W' + 'J';
    }

    if ( REZRNDNQDH == JXSQIMBTOV )
    {
        volatile auto NMVALIQXQG = 4362 + AQEDMZTYBL + 8126;
    }

    if ( DGKHDEOHEZ == BRLBUDUKKM )
    {
        volatile auto CZHSZJAHHS = INLIVMDWEE + std::string( "PZOGIJQIJICXNKTCCWIAPRQVDAARBWGYYFOXQBJEP" );
        volatile auto NBDOGGWQVV = std::string( "WYBVQBERJCVSKTVESKXYMLAKXOMMNAUGFIPC" );
        volatile auto EUFXZBSABE = std::string( "CBPRNFYXLSADLMTWXIUNEKBTGLYUZOZBXEBF" );
        volatile auto YPNWJPXRCN = std::string( "ZTRLPYRPRKQZKTYTGSEHSC" ) + std::string( "OTDMBPBOQJFIGNPTMCDZKWLGQIJMDEYNSPFEPTRPGDLY" ) + std::string( "RIXWSFOKLKSQRIKETKNTGLMACHHXKEPN" );
        volatile auto WRXYJRTZON = ZFZZOJWSLS - 'M' + 'X' - 'U';
        volatile auto ZTSSJQWAPC = 'F' + 'G' + 'D' + 'C' + 'M';
        volatile auto XBJCDUKHZY = 'P';
        for ( auto i = 0; i < IAOTYUQDPQ % 500; ++i )
        {
            volatile auto NEHELLXCGV = std::string( "UAODKSQPQLGLWKYHMYTSDJLAUIFYTIGKSLODJWV" ) + std::string( "TDYNLPOIBMRWHFVSLWUYPDZMRLEZPZCVUW" ) + std::string( "QAEMXGIAXQELWALOTBKVBLTPYNTGCBJSWBVDVC" ) + QMJSNXGLVP + std::string( "HOOJMCXVHMOUEHSQZNIGLYNPM" );
            volatile auto GRVDNQVHOT = std::string( "GBYLSFXMGPWOLVNXXIYKJDCMEMYK" );
            volatile auto RCRVOSFTCQ = 1049 | 4539;
            volatile auto ESPWTKZQDP = std::string( "EPHYGFBFIWHLLREMKOUKYOESK" ) + YPNWJPXRCN + CZHSZJAHHS + std::string( "MYOTHRDZQGQKPOZEFBHLHRYVLKLBX" ) + std::string( "ZDGGIMKNSSJJQAUATIWFCCETSJE" ) + std::string( "YBOFSDNKKCHSTACEXYNNYHSV" ) + std::string( "NWLPEZUOJZJEWAKPEBFRJSFD" ) + std::string( "NXIYMDLAFANLHQDCZGUUR" ) + std::string( "JJCHTGEFHFYYPMJFVMPWEWJFGHXJLBPKZQBYNWJSCPNLJSL" );
            volatile auto PYFETNZWBL = OFRZHMIFRV - 'W' - 'R' - 'U' - 'V' - 'S' - LWFQZPAUUK + 'I';
            volatile auto AOXKPJHVUM = 5489 / 6410 * AQEDMZTYBL + 6545 - 5518 | RCRVOSFTCQ - 779 * 9870;
            volatile auto MOGCUZHXCF = EUTCVXGMJD + std::string( "AFCNSHFZRGWVVWDOPZGTMQHIJK" ) + std::string( "DNYUMSGNCBRTNZRYTJXTEISGZ" ) + std::string( "RDPCVIMHGPWTTYKLYZVUSVYHVKZZXYCDYDCFIRJZFYTY" ) + std::string( "FHGLINKHMTVQWFDHQVPTCATEAUIOBRCAAGAALYRSOLMVW" ) + std::string( "CKNFVGUQVPQFCWREWEQNXIGNWJLWWQRLVMIN" ) + EUFXZBSABE + std::string( "DRQUEAIMUYUEYEKQNEBJLLVSH" );
        }
        volatile auto STVELIDWOJ = 973 - 1960;
        volatile auto VYFFBCIKWH = std::string( "DQTFEAPJZBZNPQDFZZMQWLP" ) + std::string( "TKSPDILWMCGPCKSNCDOGRBUBWEKTKYSTIDJ" ) + std::string( "TYAADFBVSPQSZYSLOKMHZAWGSVGVDXYFDLRUKXPOGI" ) + std::string( "USBUIIZGSURLOOGXBQVYARJQPALWCAIMV" ) + std::string( "FDVCVBZQLLDJKEHWDDSLEQWXIDLAOJZBNCKXQ" ) + std::string( "KLXXKKPGYURPYCCMBWITKGKWTCJGQ" ) + std::string( "QRYQIKSGULTBSXEBBEIAIPOAWQGZFKYTQYTOLFKRQZVY" ) + std::string( "BDXTSETBKNZKUDPQVURKJUPADKKAJJZZYM" );
        volatile auto MSMXYKLAIM = ZFZZOJWSLS + 'I' + VHECCGUKWX + 'Q';
        volatile auto WRJMXPWKSE = std::string( "MDJRYYQPNSBARBTODXBEIWOJLMKNXCYW" ) + std::string( "LRUHKLDAWOCPPZFMNCRLTEKBLKBBTFWZDSYURCDMYYZA" ) + std::string( "GGTWZJCHQSCLWBLVKZENUE" );
        volatile auto QOECXRHVQR = ZTSSJQWAPC + 'U' - ODITAAFUXP + 'Y' + 'F' + 'L' - XBJCDUKHZY - 'Z' - 'T';
        volatile auto UNWBADIGAH = 7953 - 5386 - 7884;
        volatile auto ANHTURVQOK = 8259 / 9407 + 6688;
        volatile auto KADIWDYSVN = 6682;
    }

    volatile auto RPXQIFHURU = QKKEGTPDOR + 'O' + QKKEGTPDOR + 'F';
    if ( QMJSNXGLVP == std::string( "PNPAWEJOGZQFUPVMQYJJLNROJSRMMOXOOTZTE" ) )
    {
        volatile auto IRHOADHVME = std::string( "YEWOVUFWYAQVVCZYBNDADEOPHGPWFMDXLTDDGSFWYBSKKB" ) + std::string( "GPFIRMXTJBZVSJHGBBLEFFVKPRY" ) + std::string( "GMQSIEKVEEJOSIKBBTVSZOGMNBQHSXRP" ) + std::string( "YHIADXJWWXLRGEEHNDCGMTCBDTNOGPNDVT" ) + std::string( "LJJFRCTMZEFGWJKVQGJIWMQYOWYISRAOWQH" ) + LZAJUTHAWP + std::string( "ZTKQUDLTIEQKGCHQPJYYNSGXCCDXANNKAYIJUJC" );
        for ( auto i = 0; i < 9239 % 500; ++i )
        {
            volatile auto MMOSZNTVRF = 5341 * 4013 | 1930;
            volatile auto SUXHBHLSAO = 'M' + JPSFJHMKNJ - 'L' + 'D' + 'W' - 'A' + 'W' + 'R';
            volatile auto IVBODHWCZO = 'F' - 'V' - RPXQIFHURU - RPXQIFHURU - BRLBUDUKKM + 'C';
            volatile auto UXHXYUVMIM = std::string( "XBPDIBLOYGLNYXIUDLPU" ) + std::string( "MYVIIRZHXZEFNQNVZIZJOXALJBUOBSBRTNYOCPADED" );
            volatile auto ILEBKJBXVE = 'Y' + 'N' - 'U' - 'Q' - 'O' - IVBODHWCZO - 'Y' - DGKHDEOHEZ + 'G';
            volatile auto FKFGQIDUKE = 1914 | 3095 + 6203 | 9531 + 7072 - 869;
            volatile auto JGVPEZTLQI = 'Z' + VUSYUQGBAK + IVBODHWCZO + 'C' - 'X' + 'T' - 'X' + 'I';
            volatile auto AGUGKKMDHR = JPSFJHMKNJ - 'V' - 'R';
        }
        volatile auto SZJSOWDGCY = 'H' - RPXQIFHURU + 'W' + 'W';
        volatile auto LIRWTLYHST = 2438;
        volatile auto CHQZDDBXRB = 147 * AQEDMZTYBL * 9421;
        volatile auto SOXYMZYQSZ = JPSFJHMKNJ - 'C' - VUSYUQGBAK - 'X' + 'Y' + 'G' + RPXQIFHURU - 'D';
        volatile auto MUNSATBDXS = std::string( "IAKTECSRLKYTVZJHLIBTIQ" ) + std::string( "ZKWLWXQBOTXVRIYOXGZXTTSPGZAHUVNJTXVPMVOLLSUWNI" );
    }

    if ( QMJSNXGLVP == std::string( "YYOVBHWDGBSYVWKGPZWLUKCZJQWFD" ) )
    {
        volatile auto UXCXWTQTIA = 'N' - 'Y' - 'R' - 'E';
        if ( HLNJGVFHOT >= 6450 )
        {
            volatile auto ONHUYRBOFK = 6247;
            volatile auto MIXGYSREZX = std::string( "PNQQRRRWJZGYYZIAHNAC" );
            volatile auto KNCCUMGJPW = WDGEUPUFYM / BXZEPJZRVR + 1497 + 1097;
            volatile auto OVDFQMFULA = 5383 | ZGWXRTDSHH * 7501 - 3535 | 993;
            volatile auto LOCEKNSTZF = KCKLUFWXQE + std::string( "ILOHYFMLUHITPSETCHASOWXQINUNUSJHBVMFQLWTFMNCGOE" ) + std::string( "KKYRCXBSUGZDRLGMCIUJTIFYPFFEZLZQRMLJGULEFWKJQBWS" ) + std::string( "RWSIGILFZXFHWQEXXWIOJNIKEVXCHJEGTONIDCCHPQTYKZ" ) + std::string( "DLLIYQSYNHDVTVTAZSTKZEMUSZEWO" ) + std::string( "FLMAAONJORNVKEIZYQQYLVK" );
            volatile auto BXWBESAQEO = MIXGYSREZX + LPHBNFJOYF + std::string( "DICWOQTIAFODOSPVFGSUIWQFQCQQSW" ) + std::string( "PQVSVFVIKMZLAHRWGLACPEPJBY" ) + std::string( "XHLVJMEFQORFZRNXWPLBLRWLDJCEEPYA" );
            volatile auto EPHFSLEKKC = 29 * 3850 - 4799 * 7789 - 9276 | REZRNDNQDH * 2354 | 4256 / 4139;
            volatile auto MBFUHSRTEG = AQEDMZTYBL - 4036;
            volatile auto TMPHKAPDHY = std::string( "ITEQESTNYIUUJKXTAUXHUVSSEQNWGTLO" ) + std::string( "ZIQDXEKLSIQMAMLOEWHEWGUNJYPMXVB" ) + std::string( "RFNYRBJWJUUMTNDTYPXOWHXRRTOOUXFWWJDHWZXLNZRYBW" ) + std::string( "HYNUCMPYQKKVXYRMAXPYQVVFTDWSKKITZZSZYTWEJCGOY" ) + CVYUUKBCNP + std::string( "BQWXGROHALONOGGSJUWMZFZOTG" ) + std::string( "VDKDDIVSXWAIPVABFVRHDAVXQCWCYNTYPNZSCWCQSBIAP" ) + std::string( "MNAMTTJDCSCWIYJTAPCRUHGUEQKSB" ) + std::string( "ZXNQFWDPMYQGPENEGFIDJRBUYHSY" );
            volatile auto HMVGDRNFZW = 'E';
            volatile auto TPUMPKQQAQ = REZRNDNQDH / 3082 / 1689 | 4165;
            volatile auto COIRYWIYQA = std::string( "UQCKPKWZCDDTMNCHDVECOJEVAG" ) + TMPHKAPDHY + std::string( "WWEVSSTKGMAICMRLLGKJFUBJOECO" );
            volatile auto AZWGSEJDHM = 775 | 2457 * ONHUYRBOFK / 3522 - 9708 + 9790 / 2317 + 7043;
            volatile auto UDEJZIFCFA = LPHBNFJOYF + std::string( "FVSWIIWOABDYSBHHXPQKXGMBALJUBOKXMPA" ) + std::string( "PHFSAJJPZIRVXZCMLQFMDAIGPKRGWXRTNY" ) + std::string( "HABOXECBJOYZCPRCSBQYIYFPPOGQJDZRXC" ) + KCKLUFWXQE + std::string( "AGAALDIULYIXMSFPHCAMBXKACHWJZBSUMTJWYRLYUVUKSQ" ) + LPHBNFJOYF + std::string( "YUJFNKSJIQPQBSFDAILCDAJVXBF" ) + std::string( "EGMKAZRESOQZWRMBDYLOHMEUD" );
            volatile auto IJXESVDFQS = std::string( "DSBWEXOMIPNDKNWHVORWMBDCLZSZBSDORYBSMEQDBJQVQVBT" ) + LPHBNFJOYF + std::string( "ZMLLDVQYOVCKHLPXZUBRTGSMADNULYMYA" ) + std::string( "QINUHEUJYSSTZLAIWNPJEJWTGISSVGH" ) + std::string( "SYPPVAXNYEUFGLUOYMCNRL" ) + COIRYWIYQA + LPHBNFJOYF + std::string( "IHUXDJFKFGPBKGRLSUVOPPIDQZGZYFQKOYCZKAYVDN" ) + std::string( "KDTYRGECFMAQFNMERBSWZKCLTBEBJWSENNEUJBSTTSYADY" );
            volatile auto EIGXZAHEQB = 'G' + 'Q' + 'E' + 'K' - 'F' - 'S' + 'U';
            volatile auto ZCOWGBQESI = 610 / 9524;
            volatile auto OCGKRDSGGI = 'M' + 'H' - EIGXZAHEQB + EIGXZAHEQB - 'R' - 'U';
            volatile auto GOAKVJMMZC = 'A' - 'W' - 'F';
            volatile auto QHVMGIKBJC = std::string( "EESZBXXGIAJVZCQRNDXVIUMWRTKUNDKNUC" ) + BXWBESAQEO + std::string( "DNMDJRVIIMCTEPVBWWPYAUOPPOXNTMMBMDHAIZWIXDAWDZAZN" ) + std::string( "IOVABGAIVTXZHAXTSMPNYAXDKYKFYCMLBOPOFWCTZQS" ) + std::string( "VIQSPCWVKSHLXSKINVKWOIHUQHCI" );
            volatile auto CNUTHYNHZX = std::string( "CZQMILDMBHHCMZZJNECRCBEOIAWOCJJSXLEAXE" ) + std::string( "PWYFHNBVCDHOOKSXOEBUZMILRPRZMRZN" );
            volatile auto NLNQXDFUAM = 'R' + GOAKVJMMZC - 'Z' + OCGKRDSGGI - 'Y';
        }
    }

    volatile auto SQCDEIFOJD = LPHBNFJOYF + std::string( "GEBQXWJGRZKMAIHXESBHOWENYOOVNPVPWGSELFGXVKWSQU" ) + std::string( "RIHOTCDVPUQDLYLDLDALWDUXZBZVGEXIEXNY" ) + std::string( "PFGFJORNOJOSCHOLWHYNLNNDMGVAYUWGZJGBXSZ" ) + std::string( "TTNFCSDSDSROUNHSTBMNDIIH" ) + std::string( "NMDEIUAWXOLPTKGXGUGALLG" );
    if ( QMJSNXGLVP == std::string( "REZBDJGLXGLSRBRPVXIZOWM" ) )
    {
        volatile auto PXZBTIUQWI = std::string( "ODNGRKXYLJIMQKFHXJYVXJTHYZVJIKYIZBVZAGQ" );
        volatile auto GSLGSKGUCZ = NBFECZYGSR + LZAJUTHAWP + std::string( "AOHYPNSUOWMXUKZCPBBWSRNKNHJINFHKM" ) + std::string( "KEOZQIPJYVTJAWLIDKHJPCLZAVFSPBEGWZAI" );
        volatile auto FPXLQBACZL = std::string( "WBLASPCLYCSEOZNNBDINDPCRH" );
        for ( auto i = 0; i < ZGWXRTDSHH % 500; ++i )
        {
            volatile auto UMBAEMNHTZ = std::string( "UODHMKTQHQNNHHDWDUWUXQGPIZQEDAFKVDZNMC" ) + std::string( "WBZISDHOZNTPNHLCRDIPJAUJILBAXUTWIDEDLNLVFYDMTVZHU" ) + std::string( "HREUXHJDHQERNKKXIQNLTFH" ) + std::string( "HYSVOQENZSKXVFYYYMVJBKHCLEWVKUQNULDYQVYVPSHFGNHH" ) + std::string( "TJCFBXDJCZHDNAUJCBWXXPLLWPELOGH" ) + EUTCVXGMJD + NBFECZYGSR + std::string( "XRILSSVVSGSZYNTZWNNZKBUCC" );
        }
        volatile auto XAXIYUSPSC = ZGWXRTDSHH | 8851 + 9075 / 1242 * 4790 / 4689 - 8896;
        volatile auto UEYPBSXVAB = 'X' + 'A' + 'M' - 'G';
        volatile auto SMYSEBAVXP = 'Z' - 'T' - OFRZHMIFRV - 'K' - 'N' - LWFQZPAUUK + 'P';
    }

    volatile auto YABJBLXHVT = 7820;
    if ( JXSQIMBTOV > BXZEPJZRVR )
    {
        volatile auto CSXNYEIEHM = IAOTYUQDPQ - 9707 - 7129 - 2066 + 6701 * 2690 - 2165;
        volatile auto JRYWFCRXZH = 8239 / IAOTYUQDPQ + 4248 - WDGEUPUFYM - 748 * ZGWXRTDSHH * 8034;
        volatile auto PREPZKZUEO = std::string( "MAEZIDWKFZMLCTKVGVDVPQJOWPNCEXYFBDMMFMKGVACQPWNDD" ) + std::string( "TGIBGJZHXQTLXAONSZZCKZHHRSWTQVPJRRBUU" ) + std::string( "UIYPDPFUZAKNNFRCAJTGYUSEQ" );
        volatile auto TAMWCQYHXZ = 'G';
        volatile auto GAQTYQBRAY = 'Z' + 'D' - 'Z' + 'J' + 'R';
        volatile auto RIMHFMROSL = 7113 / REZRNDNQDH * 6094 * JXSQIMBTOV / ZGWXRTDSHH * 7718 | 6831 | 5111;
    }

    if ( HLNJGVFHOT >= 1622 )
    {
        volatile auto GYMYWLDLEG = 'Y' + 'V' + 'K' - 'T' - 'R' - 'D' + 'T' - OFRZHMIFRV + 'Z';
        if ( ZFZZOJWSLS > 'P' )
        {
            volatile auto LIFJLYTHRT = SQCDEIFOJD + std::string( "AIKFISZDNNKEOFUFBHUYIOSYKZUBOMWEKVJB" ) + std::string( "SDGSQUFLQLVIXXOBRFUTVTJXCYACDGWYTGJL" ) + std::string( "ZQKUVRMSZTIPSTCIJOWORODUMREDYIAPGAAMSMAHGOKSXOVW" );
            volatile auto ULHGKNPHEM = 1131 * 7367 + 1290 * 3065 + 6710 + 9543 * 3373;
            volatile auto UEAFOJPANV = std::string( "RATMJJFVYQEOPUDLBUSE" ) + std::string( "SKNZYSVXRRLECVYRJKFBCKNCGVIEAHJTRKWFGENJYU" ) + std::string( "RHWLSCJRXJISMSYSKFXVCHYTZQAAWIUITUSPJVLLAGXCMK" ) + std::string( "CMCCIVPPZYRZJJOTMVVJVHOMXRHALE" );
            volatile auto FGJJISLIMM = 'P' + 'K' + QPTQZHFZVV + JPSFJHMKNJ + 'U';
            volatile auto TISDVMVCNF = std::string( "EJJUPPFDPEAVJBBJORIXCXXJBJE" ) + std::string( "JXJUJIWXSCEXJCFEHMASG" ) + std::string( "PZASCNAFMLTSZRNQUVARGVXODBFYXNTPLITDE" ) + std::string( "WIPCMBIUBMOBIBHZSEHRXJMIQCRTAYZQIT" );
        }
        volatile auto ZYCSXDQXFV = APZXYVSUOJ + 'B' + VUSYUQGBAK + 'P';
        volatile auto PTQFRALEZG = 9596 + 8385 / 4285 | 4714;
        volatile auto LZQONHKWMD = 'Z' - 'I' + QPTQZHFZVV - 'L' - 'U' - 'G' - 'F' + 'O' + 'E';
    }

    volatile auto RALTXIJWCL = std::string( "FMJDQBUHCRADSPUMHUVSXXTDTCOPAVZLAFHEJHGOLWSEUEHL" ) + std::string( "MEHGSPCMHPDAOGHAEPJOUCTIHMLNEZMCWRBH" ) + std::string( "FZCDXVTJKYYFDOHHDADWEALTDENZYMUUOSIFWIFBYS" ) + std::string( "OEOJZSITLYDEQLGCKUVCY" ) + std::string( "MEDQNJMTEHXNIPPHLLJRHDBATDCOIIJP" ) + std::string( "GHXGOSZPYPDJCCWJGXLWYHQPMH" ) + LPHBNFJOYF + std::string( "ITQHPUEZONELXWHYQHUHOZBAGFZGIKDKXVOEQ" );
    volatile auto CELATXBNOV = std::string( "OQTQJRFJGEPGLJGCPHZPGAWHLHAEHGZAMKQEMWQQLNYJRJN" ) + std::string( "FBQABAEOUATBQSQIDTCNPBUCLFJTMJTCKZ" );
    volatile auto KLXECPMESL = 4318 - 3566 + 1677 | 543 + AQEDMZTYBL * 8032;
    volatile auto MNOTXXRXQM = 7649;
    volatile auto YOWMFETMPG = LPHBNFJOYF + std::string( "VJWJCPIPJCISVYAFTEWJBQEQMJLUYDS" ) + RALTXIJWCL + std::string( "EORGJCYKIOZEHPHHNNNRKOLUCNQJDLGASECNCWHBXP" ) + std::string( "JQCWEWLPGWHYMDMUERFLUUYSPG" ) + std::string( "SKPIISMGJVOIVZLGLORKHXHWJD" ) + LZAJUTHAWP + std::string( "WUBXHVCBAFUAYUDTYFQTPJMNYXZQKZ" );
    volatile auto YBNUMWGPPZ = AQEDMZTYBL - 563;
    volatile auto ATPYMIKDZK = LPHBNFJOYF + std::string( "AZNKMCWJXFLXOKIMICFZJRRIQHJEGSLCBGIVPNTFRRPCEKZTN" ) + std::string( "RDETIVIBMXUJZHRBPEGIPRNRWJEQZOKTOMZOLJVPQR" ) + NBFECZYGSR + NBFECZYGSR + LZAJUTHAWP + std::string( "JGSIYZXMWXYPBIFMGGURMRWEGKXCHJCAKCCUBFJESTMTT" ) + std::string( "JOBOCUENVXEZGLKBXQZTFDLXVNYEZUDKTKLNDUCX" );
    for ( auto i = 0; i < REZRNDNQDH % 500; ++i )
    {
        volatile auto TSIKGAPMFC = 909 | REZRNDNQDH | KLXECPMESL | IAOTYUQDPQ - 4160 | BXZEPJZRVR + 8011;
        if ( REZRNDNQDH < IAOTYUQDPQ )
        {
            volatile auto XONKIAMFFA = 180 / 6346 - 5064 * 7285;
            volatile auto CIIRCTBDFY = 7396 * 6631 / IAOTYUQDPQ * ZGWXRTDSHH + 9506 + 9052 * 8669;
            volatile auto SWSJBRYZGE = OFRZHMIFRV + RPXQIFHURU - 'N' - 'J' + 'O' + 'J';
            volatile auto QBBCCCUAKX = 'U' + QPTQZHFZVV - 'U' + 'W' - 'D';
            volatile auto CXGDRDLVQE = std::string( "WUZNLXBRDYNFKCDEMGYTXCLKDMZXTNITUR" ) + EUTCVXGMJD + std::string( "PUJOKYXDXQQTLSCFNOJHIZZQZRHKRICNCYCGNDOYTHAM" );
            volatile auto MMZXWKKNQU = 4012 * 3893 + AQEDMZTYBL - 5171 | 2983;
            volatile auto NTFIZZADKY = std::string( "MCFZHIREDAESKETOJOKWNOTYQHVLKXXEGAEDATPPFT" ) + std::string( "OGYJHIAMGTGDZLJZPNQYVQ" );
            volatile auto UJWVDQZACR = 'A' - 'Y';
            volatile auto DGCXTOUVUF = 8263 * CIIRCTBDFY * 9221 - JXSQIMBTOV | 692 - TSIKGAPMFC / 4591;
            volatile auto GONXZLCCPC = 'K';
            volatile auto LVAIHWYNVL = std::string( "ZUDJTKXNYKVXRJSCOBGKMMMS" ) + std::string( "SIBHVQTJLKGOAVCPQWRNHL" ) + std::string( "KGZZPWSDGPXUBNIHWLQOUHYMGAKGVCUWHKKWQQ" ) + ATPYMIKDZK + INLIVMDWEE + std::string( "VZHSBQQQDOPHPDWRJJWBAQU" ) + std::string( "RUITJRMEWYBVWNJLLKUBCEFFC" );
            volatile auto PGPJGKMCJQ = 'K' - 'Q';
            volatile auto LBGCULPNGL = 'G' + 'Z';
            volatile auto DVLUAFYIRP = CXGDRDLVQE + std::string( "CHSONAVLPLNCJMDHCZHDQGBPCBWEHJJ" ) + std::string( "OVWNEUHRMMOSVGDMLDQD" ) + RALTXIJWCL + NTFIZZADKY + std::string( "ZRXHSGKCKXBNTPVNBACXAOAZWVVPUJGX" ) + std::string( "TKCZHKZSFLUKLRXKWLUHBREBOLHJOW" );
            volatile auto FGPUWOEVQA = 'A' - 'Q' + 'M' - LBGCULPNGL - LBGCULPNGL - 'Q' - 'G';
            volatile auto GXZSKYGAGA = GONXZLCCPC - LBGCULPNGL - GONXZLCCPC - 'G';
            volatile auto DAHNDTUODN = std::string( "CMTVYGYDNOFHCVUULZZPCZPGFMPNQWJGVFVMAWPWNSQD" ) + std::string( "DXMQLRLNQEYMWAHUOKCCJIMQWUOIIOGKZNRPNGDFC" );
            volatile auto VZXNUSTTIU = NBFECZYGSR + std::string( "VSNSKIKXGFLMPWUUBFLOTPMZFOHCUMAMISQTPGPOOGCGFSRP" ) + std::string( "AIDUEYEWFAFUPXZNNFTMXSLSUBMANLMBTUNGCICGNUJQ" ) + std::string( "WKZDLDIUNEAVJTLEDMZCIUWWSKRWT" ) + std::string( "PCRXOTPGNYHAVZCNCLBMLBCXGZEJTVESPQ" ) + std::string( "ZFHDGNTXANAUQPOFMSUPLFGKIDHKJVVPXNZYCPOQYR" ) + std::string( "HUYXVDFJOERLWDPQDXEDQUPASXVTHMR" ) + std::string( "LNGOEYMTGIPTMEXEXHMBBN" ) + std::string( "SEMMJQUVTLBHUTACAWDYNA" );
            volatile auto FHOWUDPXRU = NBFECZYGSR + std::string( "CMIZKJKOGBQCLLFZXHNMZFUZIBCMDYWMHZXRUCIUMVBKRH" ) + std::string( "RJGXKHFDVMNNEUZTZEDKHATSUQRVEE" ) + INLIVMDWEE + std::string( "FIMBODTTHAQPNCUPJZQKNNSKAFKTKEUOXWOHFUPBIGSLU" ) + std::string( "CAJTZJDGBRQNMKPKPCGUHQREXDGIHTMNWRDTGI" ) + std::string( "GICXILJEVWCUYIFDRUHVEHU" ) + std::string( "NELYJRKCMLUVGJMGGJMKYYNSS" );
            volatile auto JVWPRTVBRS = GONXZLCCPC + 'T' - 'W' - OFRZHMIFRV + 'M' + 'C';
            volatile auto ESJJLQYUEF = std::string( "JAIOCCMDLAVYNERNXKQFJOZJQSCSIBPQFRKBZNZSPRX" ) + std::string( "VAZYKZTVJLFTWUPNJLYQRRBFRKCYTKFA" ) + std::string( "XELGEBHZRBSDZTGZXVBZGFGPFPNUVFUVDNI" ) + std::string( "BGIPVAUOHRYWBPONDMGXAMKTABBJWAWTB" );
            volatile auto LGKUAPGROD = 9612 + 8878;
        }
        volatile auto FWFWFHXYNK = std::string( "YVOSSJTRDTQIQIMYBSJMOYTYPCZH" ) + std::string( "QSTXTPLPTHKXWATZBPDPJMSUPDWPDXUFINVVFVFZRKNSYG" ) + std::string( "IQTWLWMFPJEXTGKEYZZZWIMLGZKGMMARVHNPFVZRFSRGGKKG" ) + INLIVMDWEE + std::string( "MSUYDAHUDRGEWODBXPMMUF" ) + std::string( "YOJQTMXGYHXCSXHEUMWAIHDJZXNBV" ) + LZAJUTHAWP + std::string( "TFBASAQKAQWZWLUENREHSNNQWLUZWUEJXCBYBJTOZERQZASC" );
        volatile auto EIIFGRLDGF = 5473 - 8874 / REZRNDNQDH * 8491 | 1677;
        volatile auto LNWPONYKIZ = DGKHDEOHEZ - 'D' - 'I' + 'K';
    }

    if ( OFRZHMIFRV == ODITAAFUXP )
    {
        for ( auto i = 0; i < 2372 % 500; ++i )
        {
            volatile auto BJVBVQRNSD = 'F' - 'X';
            volatile auto EGWJTWGZOL = VUSYUQGBAK + LWFQZPAUUK + 'Z';
            volatile auto RHPABDHVAJ = 3565 + 8987;
            volatile auto CVRQOQSTRJ = BJVBVQRNSD + 'H' + RPXQIFHURU + QPTQZHFZVV - 'R' + 'B';
            volatile auto LAWSFJAFZM = std::string( "WZAEIKEEWMWUQBYDXWYNMOHKUMOPWJUBMFB" ) + std::string( "OXSGQDDAHRPJWWPHNRVHLZ" ) + NBFECZYGSR + std::string( "WMPTTOPEYQOROPCQXOTRFULWXEJNXX" ) + KCKLUFWXQE + std::string( "AOOBHMPBIDCASVPEBHBIJKUUATKWUGYER" ) + std::string( "BEQDVIZPLBPUTAOBTGCFYIHYZIPRPQGNDCZPUSYXZ" ) + std::string( "LUSWRDMTHZUVCRRBYHBIEFJCYRFGEQFSJRRHGSCOLERP" ) + std::string( "GKQYZYGOQTCLKAJUGEMWANUQJNDVUODUUBLWQU" );
        }
        volatile auto AVJCUCBOWY = 'Q' - 'H' + APZXYVSUOJ - OFRZHMIFRV - 'K' + 'N' + 'A';
        volatile auto TEVHOFVHIU = 'O' - 'M' - 'R';
        volatile auto UHAZBYTXWZ = ATPYMIKDZK + std::string( "CKSGEDRNIDPVPGUDFRLKGRSARNBYNNZQ" ) + NBFECZYGSR + std::string( "GMELSSOQBSZUDYTSTAXRHEUDBGD" );
        volatile auto PSJOSCBOYT = SQCDEIFOJD + std::string( "TJTHWSRQZEYXFUQXJYZXYONL" );
        volatile auto KEZCNOUQIJ = 'H' + OFRZHMIFRV + 'X' + JPSFJHMKNJ - 'L' + 'J' + VUSYUQGBAK - 'Y' + 'U';
        volatile auto JYLRIBVDLP = std::string( "NOPNNXTLIHRZWRULBTEBPYBFHWQALHKGQABEZIPVCBQUUH" );
        volatile auto ZTLHONJFRH = LZAJUTHAWP + std::string( "QHVOMRIBBQKZHJQDTZFJRXOXXDAMMVPFFZLNOXGPZWDTF" ) + std::string( "SXRJRVPFAFTIXDOVTPKUUVSJNTRSMMHPUSURGXYDH" );
        volatile auto UHIRFNJIFK = 3400 + 9821 / 9939 | YBNUMWGPPZ | 5887 + HLNJGVFHOT | 4299 * YABJBLXHVT * 1584;
        volatile auto SKMOHCLZFE = PSJOSCBOYT + ZTLHONJFRH + std::string( "HFJPBLRMBQMCZWVVSOGZLOEEWS" ) + std::string( "JUTTWDQYMKGSGYBYTSAFSIYIETMZFJCMLDELG" ) + std::string( "YVBIEWBWKPCRRTDHTGCTPSCAYRVCVGOQH" ) + std::string( "KWECUIJZLVFTAJMAYBEAMJDMPGQYVPBXZKOVQA" ) + KCKLUFWXQE + std::string( "MORLEVUIUQVRKXAFWVOLKVGVDPKNFXHOCZNMGTMZ" );
        volatile auto KYEWHNMFHL = std::string( "PCARPLXZNBYWUOVLZIWIGJFJEUTNJOSMBXCTVF" ) + std::string( "LDAFJGWRNUSKPZJLVWMCPTXOEFDPIYUPMQCOLVOWWE" ) + std::string( "DRFLAEDHIOACYZWVZZIPFLCIZKTWJTORYNNKIAUKTPWCPNWM" ) + std::string( "KGXOAIDKMMMZEYWQPZSMOHMZEDWXUVVLNEZMRHB" ) + NBFECZYGSR + KCKLUFWXQE + std::string( "QQQBMAYKZHYMCDHOBOXZTRTGGM" );
    }

    volatile auto XETDUJHWDF = std::string( "ZQWARJIKMKYUGMVAHHHP" ) + std::string( "RNOMFLFSVXGKMCVQMVUQDHPTDJRPAXDNULD" ) + std::string( "GHSYKDAJKYUIVUQSYTSQ" ) + YOWMFETMPG + std::string( "JUBSUDAYBLWVUHLYGFAVJFLUXXBHMJIKYAIWAHHOB" ) + EUTCVXGMJD + std::string( "RDLWTZPYZXMUHIJBGQPRBFGDVRDOTMLLHP" );
    if ( QMJSNXGLVP == std::string( "KVZPLNLPPHDGNKIVSTMQHLIPOHOBDUDOTIIGZDZDOSBLP" ) )
    {
        volatile auto IGPKJWVOZM = std::string( "GETWPNTZPPJCSSPXKJWOKSIHLZFXIDPYUVZQUN" ) + SQCDEIFOJD + QMJSNXGLVP + std::string( "MKPIWQMZLHWTYDWERJPYDCKWTHZHSUGPKUICPWIEHEUTF" );
        volatile auto YSMEQQSKAT = KLXECPMESL * 2874 + 1242 + 925 * KLXECPMESL - 3007;
        volatile auto EYRRDIDWQY = 7555 - 8276 - 7412 / 4805 | 250 + ZGWXRTDSHH * 1089;
        volatile auto CQCDOSUNHV = std::string( "TEDROPSJVSQALAQVUUQYAN" ) + std::string( "MPPJTXQRVXDSXWMUUBGOBGSDZVZKT" ) + std::string( "IROWZVTVVMDTEGGWMKXYGYHJNKTI" ) + std::string( "GOXBJWCXHETADUBKJFIOBKKHCCFXNRTEKYRRAGAQIWAHVIXTF" ) + std::string( "FKQKOQECJJCERGFKDLTFMRELUFYAWNKITZCLKWGR" ) + std::string( "EEBENGEPISDGVZUKSDUA" );
        volatile auto LWWFJAYTIL = 9999 + 356 - 9224;
        volatile auto AICWMVFARK = std::string( "GDLZQBJQCIOUNVLUCVCBEVXELWZRXRXMWGZGJPUOFW" ) + std::string( "PKFGOUBSSLLCXHWFLMBOWIHVHWOTBUPVFXROACBZMNDCRUQZ" ) + std::string( "FHQYWPWAQHEJLBBIEEEMGPKQBAUNVKLQCJTEXFGB" ) + std::string( "GNLQXZWVVIEFVOGCIXLZXDOPFJKSXVXBINKPXCHXILFPLEGR" ) + QMJSNXGLVP + std::string( "WIEREFPOQMXYEBCTQWFETGMH" );
        volatile auto THFMGEIHXM = KCKLUFWXQE + std::string( "YGMAOPGUPFPIBADKVYWLRFNUTPEVYDEQUGVVMTJMJQ" ) + std::string( "ZCSSSHYKLWMAZNUFIXCOKBBNKYJGTAKICWVECCUMLB" );
        volatile auto CWWOFMPSNJ = 858;
        volatile auto FDPDIEHHIB = 7898 | 4033 - 3628 + 1830 | 8116 - YBNUMWGPPZ - 7660;
        volatile auto DEUPICECOB = 'M' - 'Z' - 'Z' + DGKHDEOHEZ + 'Z' + 'V';
        volatile auto MDEEEQKSUD = 'M' - 'G' - 'W' - 'T' + 'U' - 'X' - 'K' + ODITAAFUXP + 'I';
        for ( auto i = 0; i < FDPDIEHHIB % 500; ++i )
        {
            volatile auto BSTYTGICFA = THFMGEIHXM + AICWMVFARK + SQCDEIFOJD + std::string( "RZLJUTCVBYNOJLMILYBMZFIBNODNMCHL" ) + std::string( "XZAMVLXCHPLMRJWFPOJZRBTSEZTJSZLDR" ) + std::string( "UWFFAMMNOUVFHHWSNJIEIUUFI" ) + std::string( "ESNZQDCIIGJVHRWUAWZCAXJNQETIXQTXTFJ" ) + std::string( "DPDPSLANHJZILKTKSNLBC" ) + std::string( "PDQTUBAMTRCGVWGGYMHWDZYVKEUOCQKKLCTITAQRNZIKFY" );
            volatile auto QPCTQFUJPG = JPSFJHMKNJ + 'Z' - 'P' + 'Z';
            volatile auto RDYPKUKZNX = CQCDOSUNHV + std::string( "CXQVKRPKGCIGTOSQFPHKACFSQDWDMPEFWBMS" ) + std::string( "WIEMSYNZRYEGVMXQXCJSCAGFWXULQXZK" ) + std::string( "VMPERVKQXVIWCZQUECJUYURKFUGFPKEPZ" ) + std::string( "JALBSULDFMAVFYWPEBMRTW" ) + std::string( "WTUEWQTLUHJOBQXFIHACIMSWUEFCO" ) + std::string( "ICZFSLYLJZHGVAKAYJRKQWWLQREOTKIDEDZJTQCTHQFYPMBW" ) + std::string( "AGKRYQECRAAHHGYCZRXVDPIVRNRQSVODEBBMXZ" );
            volatile auto JJWRUPJOJI = 'W' - JPSFJHMKNJ + 'O';
            volatile auto ZVJWZNKVRJ = 'M';
            volatile auto IRBRROYVAP = 1569 * 9833 / 8895 * 1613 / 8968 - 9051;
            volatile auto ULWOFMDOWO = 'B' + 'Y' + 'D' - 'M' + VHECCGUKWX + 'W' - 'S' + 'P';
            volatile auto HLADCQABCQ = LPHBNFJOYF + std::string( "NARMLRAXKWAQZFAXRIYMZIHPKBKXZCFWGKTXDEHBQGXZIM" ) + std::string( "CCJGDYHREJOLDUNBXVSKHGXNPGOAPFLNOEACXUNIQ" );
            volatile auto AJORONUAFT = 7371 + ZGWXRTDSHH | 9436 / 3587 | IRBRROYVAP | 3146 / 3856 | 8006;
            volatile auto NITTHGXCXJ = 'Q' - 'Z';
            volatile auto EMHVYJYKXG = std::string( "CRFPVKPVXZKAKPELMTXVBAQB" ) + std::string( "GZKONBHHRHMTRDWHYHDC" );
        }
    }

    volatile auto YHVIAWMTOY = 1616;
    volatile auto GJOYFVRIOU = std::string( "FODLJYKRTXPUWTMMTTVDLBPTAXMNEZYTIDABPEBYKHNWSONC" ) + XETDUJHWDF + std::string( "MUZWMTTLWOSXSEOTAMJJJRZPIDQXBETOMNUSWWCUJSPKQN" );
    volatile auto FKYDCMVVKN = 'E';
    volatile auto RBPYUQHIWU = BXZEPJZRVR - 2376 * 9194 | 1497 / 2812;
    volatile auto AQZXZUZPVA = std::string( "DIFRUQLAQQKATQVAGGMQNGGTDWLVKIDVGLGLP" ) + std::string( "OOLZFCBWCMNXEQPINPTIJKLDCYWDSFFRAXGV" );
    volatile auto EJKJDPFIDU = 'W' - 'A' + 'C' + 'T' - 'Y';
    volatile auto REZYJOHBWB = 'U' - 'T' + 'Y' - QKKEGTPDOR + 'S' + 'Y';
    volatile auto JQWYQVOOSE = AQEDMZTYBL | ZGWXRTDSHH - 9856 * REZRNDNQDH | 7837 * 4043;
    volatile auto EKQPFVBSVF = 'O' - 'N' - QKKEGTPDOR + 'E' + 'O' + 'S' - 'T' - 'U';
    volatile auto ZVIGXWVGAW = JXSQIMBTOV * 6473 + 167;
    volatile auto NCWQKDTDNA = ZGWXRTDSHH + 1903 - 6096 - 2439 | 8732 / 1866;
    volatile auto VAKJDLPAIU = 'O' - 'F' - 'N' - 'R';
    volatile auto PBGURXDKCV = QKKEGTPDOR + QKKEGTPDOR - FKYDCMVVKN - 'O' - 'U';
    volatile auto XYLNSKGFTU = KLXECPMESL | 5719 + 1047 | ZGWXRTDSHH + 0;
    volatile auto ZTOLLGZDRU = 'N' + 'X' - REZYJOHBWB - QKKEGTPDOR + 'Y' + 'E' + 'Z';
    volatile auto PQIAWXZDJO = YOWMFETMPG + EUTCVXGMJD + INLIVMDWEE + CELATXBNOV + LZAJUTHAWP + std::string( "EJMNSDGQARSBQJJQBICHOIMAKUSVYQLXQD" ) + YOWMFETMPG + std::string( "WYZOVXWXMCYKLRKFVLNFFZDXHULEUUISYDCRMIUF" ) + std::string( "QONMXUBHAMSCSUGMHPSTMQHZXUJLWTZL" );
    volatile auto ELQEWKBUSO = std::string( "YCKQMRXXCBKVQMEHKEWDYDLEJMDSCVVCJNIKWCWMECOJLNU" ) + std::string( "ZNFUGFHMCDULHHKYVPCSWRTIYMT" ) + std::string( "DDBRFPSAUBDDFPNKITXWTMRFOPAV" ) + std::string( "FMYOCKJDBLOFCLNQMVDPPXOJPEQWQYOIFFQHOCCD" ) + CVYUUKBCNP + std::string( "ZXVGCKTZJREPMJIPCJVPNHCIKZ" );
    volatile auto UKPCRHZFOF = 'H' - 'M' - 'Q';
    volatile auto NPFKHHVZOD = PQIAWXZDJO + std::string( "ZOFSJSVPNURAPSFTYZFHW" ) + AQZXZUZPVA + LZAJUTHAWP + std::string( "AWGNDLNAVWEYOEFPLROGWJVDKSBSVYUNODBQNTAOTYMHH" );
    for ( auto i = 0; i < 4574 % 500; ++i )
    {
        volatile auto FWCRJKCOCR = GJOYFVRIOU + std::string( "BWPFGHFDFCGUXTZSBQCCRWHWUVCRYGSMUFDXCXNFBWMUVDXJY" ) + YOWMFETMPG + std::string( "ARPBQDCXAUJNBQYTSRZQPEXYJJMDANRMKBDFTXRCAZP" ) + std::string( "EVUQSHRZWMCXDZMTZVZWQQOKDIRSQOSEMRXHKDEKKA" );
        volatile auto XXSHSNZODC = 'E' + 'K' + 'U';
        volatile auto TJLMLPCKRI = std::string( "YGHXXORMWIXSYAQEPHTMJMMILZZOZKDNUTXY" ) + std::string( "NNAYYJEMTYMYOCNMEJXEDRPFSYAMUXHB" ) + std::string( "XQFIJFKRMIHVYVFZJRRWRKLABBCZUNOSMYHCTSC" ) + std::string( "XSIZNFFGICLXYTPJZNDGQ" ) + std::string( "FMQAEZUWNLUMBRQKRWOAVIKIQYXRYLKUOLSMDOEATHSFUPHJF" );
        volatile auto ZNDWBHKGBD = 2632;
        volatile auto NAQNMCKKVA = 4142 | 5308 + 5728 * REZRNDNQDH * 4247 | 8855 / 8066 * 382;
        volatile auto PVENKMMCJJ = 'U';
    }

    if ( QMJSNXGLVP == std::string( "AJJQYTEXOLQQIJPOTRDBNGCEKNUURKDXPAQ" ) )
    {
        volatile auto BQWXIHQFOV = std::string( "AWWRVGXOCCIMNNNXQZEFSVUVHKSJYXLJHIIWOAVUJ" ) + std::string( "UGAEBBKLNOPFQZFFFQIQDJVCSXSUCNILESPAHDVNPK" );
        if ( YOWMFETMPG == NBFECZYGSR )
        {
            volatile auto ZBGPWXHUCF = WDGEUPUFYM - 1332 | 7733 | 3857 | 6735 / 8483;
            volatile auto JBJYHCABDF = 2044 + REZRNDNQDH - NCWQKDTDNA | 1624 | MNOTXXRXQM + 4827 / 4988 | REZRNDNQDH + 8023;
            volatile auto KFJYPSHKSW = 'H' - 'F' - 'G' + 'D' + 'R' - 'W' - 'Y';
            volatile auto JJPFPENUQO = 9711 + 6722 - 4800 / 7965 + 3754 - 9808 - WDGEUPUFYM / ZVIGXWVGAW * 3660;
            volatile auto LIDMLYXXPN = 'R' + 'I' + EKQPFVBSVF - 'E' + 'G' + QPTQZHFZVV - 'F' + 'V' + 'W';
            volatile auto CPLETIAUXD = 'B' - KFJYPSHKSW - 'K' + 'K' + ODITAAFUXP - 'P';
            volatile auto MJLKUREMFA = 'K' - 'S';
            volatile auto FRXXSEPMXL = std::string( "VRCPPGWGYPYLCHRSPDIKLPNKAZIYLWM" );
            volatile auto KPYWDLSBQL = 5659 - 7142 | 7271 + ZGWXRTDSHH * 3431 + 8448 / 4925 | 9214;
            volatile auto RSXKRXRBBT = 3216 * YBNUMWGPPZ | XYLNSKGFTU + 2612 + JBJYHCABDF | REZRNDNQDH + WDGEUPUFYM + 3844 + 5220;
            volatile auto EQSDPQOFAF = std::string( "OXIUWENVWUUIFQEEBSXOPRGTUAVOBRKTMYYN" ) + KCKLUFWXQE + std::string( "GYWQOAWJYUFKAVGRRAIBYKZFJFZLRHKYJZFACWPSTP" ) + std::string( "ZVWZRHJALRQJHBBPGPUKQHJECXXRZDGQ" );
            volatile auto EJAKPGRIYO = 'S';
            volatile auto RAIKAOTRWG = MJLKUREMFA + 'Q';
            volatile auto OQANOYGTQC = NCWQKDTDNA * KLXECPMESL + REZRNDNQDH | 2538 | JJPFPENUQO * 4887;
            volatile auto QKOTBDQEDY = 1712 - 3101 | 9644 * 2556 + 4282 / 6181 | 337 - IAOTYUQDPQ - 1829;
        }
        volatile auto WCVTXVDMGC = INLIVMDWEE + std::string( "VVEWUNRWDGAIOIWWPCVXEIYEOAU" ) + std::string( "MPQXINIAVFGDBQFBNWZIUTSZ" ) + std::string( "NKQRFZYURCJPGYLYFHJSWRZMTLMME" ) + std::string( "YIVMEQQXCMRORLWKEXTMMPCXGIIKISXEOWYJDZPVWOCC" ) + std::string( "FYFVHFPJOMAUMMGEIXQYMAKTSXSPQN" ) + std::string( "OANVZELXBLRKWFNMCKNZSARUGWIBKPJAZTMKGXXNET" ) + std::string( "ANJSOCVKNMBRLDSCFFMZVZOHGDDKIBYGXASZANIVRTGZHWSP" ) + std::string( "LYLCLOVUKKTBSWRHCSOZJLOESZMOTXRAYA" );
        volatile auto LMBHEMNJOA = NBFECZYGSR + std::string( "XBPEWDSEOKCHTDJDDOTIHHYZUXIJBIXKGCZKIDNGMVGA" );
        volatile auto LWRLWNHOPD = NPFKHHVZOD + CELATXBNOV + AQZXZUZPVA + std::string( "HMCRSBLJOSPPNMFXNLWCKZ" ) + std::string( "CIXUJMTYEGJFFWHWOQXPRHXQJSKLENOBKSKWASCJIMVJ" ) + ATPYMIKDZK + std::string( "RIVNMKWVONGFMNOHXPSWABKVPPKTHLHASDRUGHIH" );
        volatile auto DIXIYSCTNQ = std::string( "RNGQOCJLLWQXTXVGUCCGIIKGHJBDPMELEP" );
        volatile auto VTGTJMEUCJ = 2126 / 4870 / 526;
    }

    volatile auto PDMOFOONMO = std::string( "IRQHLGFMOULSMIQRAYVQUDEOIIG" ) + std::string( "KSYVYNDIKDJLJUXLENCZDZQMBLYPASU" ) + std::string( "LQAZSFAMIGFGKBMTMONHRIBPVIZOVHBTDEEVBMFKZGMCQ" ) + std::string( "PKDJGMQAFMCGWQRZJCHLVYZM" );
    volatile auto GOOBLABGQI = 5955 | 4464;
    volatile auto FVJAQNYUVJ = 'F' + 'X' - 'B' + QKKEGTPDOR - QKKEGTPDOR - 'L' - 'E' - 'T';
    volatile auto UMQQDYQYIE = 'G' + 'N' - 'G' - 'I' - 'W';
    for ( auto i = 0; i < REZRNDNQDH % 500; ++i )
    {
        if ( ZFZZOJWSLS == 'V' )
        {
            volatile auto DDHCINHVKP = 4724 + 6566 - JXSQIMBTOV / 4376 * 416 * YABJBLXHVT / 1935;
            volatile auto SVLWAUJUFS = std::string( "NFNSFEVRBIODDADPLGGRCXWAFNHWBTDFWHFZEE" ) + std::string( "BOTJNQIMMRXYQIEJGVVDLGGYJMITNXUAMO" ) + std::string( "ZGYDBXLFAUHUABHPZPXWMBQPYTBFNU" ) + std::string( "NXHRMSIBSBKNWYPJEHVFSGFJFAO" ) + INLIVMDWEE + std::string( "NNBCOMMFOAKOHSXLMDDHEI" );
            volatile auto KVBXAMIGDR = std::string( "BWAQLVICAIPFCJDCBULLAWTFHHOGXNIWDGJEVMXNRAUIM" ) + LZAJUTHAWP + std::string( "HCENZSBVZZGOXXTZBLTGCJIUB" ) + std::string( "HIUZJFYWXAAHWCRACBXTKLPTZKUWELERDDUCZHSEJYEKY" ) + std::string( "AZZKCRLWIDSIOBUJTKMHEUEVSLDJNHIRZIYISTHGSN" ) + std::string( "OGUESQNBJBVAIFDMQZCFORENZYPECFRWSLUS" ) + std::string( "WURQIUZXBHFUBJZDJYIXLKYCXLNXMPSDMYIHOBO" ) + std::string( "FWMOELWPSWGCLMOCHCBRO" );
            volatile auto LOUSTQVEFK = 'R' - 'D' + EKQPFVBSVF - 'B' + 'I' + RPXQIFHURU + 'M' + 'X';
            volatile auto XMTDFQSMCQ = std::string( "KOMFACPRONVRTYFXUIAMSWDOORJEDOWOGZLIVPJIAG" ) + std::string( "NAOLYRITLOARHLTNWBEZRMLGRFJADWXAKZSY" );
        }
        volatile auto PUCTXSLDIM = PDMOFOONMO + QMJSNXGLVP + std::string( "OZIYVPKIONAIOXMTUGIEQASBRZMG" ) + std::string( "XVMXAMLSTKCKTFQOHGGWDDSIIMWFTHVOFQGUNVBE" ) + std::string( "ZEOTCDPOPGZMOOECYWAMFCIJQNENRQNDIFOBCMR" ) + std::string( "VOLKXWEDPZBWZSVDJZDZLERGSNAQQ" ) + std::string( "JCKDQOOYWHPNSWRXFSKVOMSJFYRBGGPIYCBBGCCYMSTPZJG" ) + std::string( "YRXNSQSHPQUPRDPLJWTD" );
        volatile auto NOMBOSESFD = 5640;
        volatile auto GQCZRMEBFG = 1064 * 4136 | 3161 - 2195 | 5027 + 4143 - JQWYQVOOSE * 8099 * 7773;
        volatile auto CMEDDSDLJA = EUTCVXGMJD + std::string( "GJJBCKMQKNLRWTVMQDOCDDLAELMKD" );
        volatile auto DSHUTFCQUX = std::string( "BPRGISRLPYVBQIYPYLFAZIPHEJBPEPWSFZMDRXTIG" ) + XETDUJHWDF + std::string( "SZKCYQBGZCCVQVVYBRXTVRAXIRBDAVXJOGUDGVVREW" );
        volatile auto ACFRFSHMXX = 6738 | NOMBOSESFD * 3280 + AQEDMZTYBL * 3809 | 4683 / REZRNDNQDH / 6188 - 4890;
        volatile auto PVNRHDEAQO = 9364 / 5617 | MNOTXXRXQM - 2269 / 6952 | 8164 / 1667;
        volatile auto TQXXTZBVIZ = std::string( "TXRDTFMNVBSDRYDYBVGFOEAODNVLCRKQLJKUGICEC" ) + AQZXZUZPVA + std::string( "WDZFKBLEQCRIOJSTTCCKELVRIYLFHWSDFVXDI" ) + std::string( "QUUGTKLHIXLPFXUJODSMOLWIB" ) + std::string( "WLKLVAZILNYEGFTQDPFXMECBYCKLWTFGRLRRIATKXAPDKIYR" ) + std::string( "PNLSHRMVOCHCWUZLOYRPDTUXAVUNYZHZNAUKOXVSW" ) + GJOYFVRIOU + std::string( "PXRDYSAQEFKGDIYWXIPLYRZFJVXGOUIASRQDMHSFOGOJHFSQY" );
    }

    volatile auto XXLTDVTBKW = 1207 | XYLNSKGFTU + 1873 / 3304 + 3463;
    for ( auto i = 0; i < JXSQIMBTOV % 500; ++i )
    {
        volatile auto ABNADALWIE = 6216 / 7548 / 149 + 3367 * 5985 * 9812;
        volatile auto HJXBGQXQAO = std::string( "KYXCDRVGJYNVNETVKXZBVEGWFUOC" ) + std::string( "BTAWEQVZFRQUEWLGSAWJDTXN" ) + std::string( "EKSOZPWQGHBBTTVLRSAHVN" ) + std::string( "JCIIHJNWGHPGWNKKYEDUSGQKVWLUWIMJSEKRMCJINLOFJ" );
        for ( auto i = 0; i < 4311 % 500; ++i )
        {
            volatile auto DTXVVVHGRL = std::string( "WHJNHSZYRLQVNIFXLMVA" );
        }
        volatile auto OVOJDQVEWG = std::string( "UDDYBPCSJBAAWSMNYWZCMKRZKTY" ) + std::string( "MGVDLLNVNNUFEDIUKMDNHRNFMMQMWWTHHZMVQGGOXYLBSS" ) + std::string( "RYUBZQTNXEQNEEFPQJGLNTCKGQLMEEKRCAOHTW" ) + std::string( "MFPHDYWKUJEGITTZKDPXWUKLDHYWTNOELRR" ) + std::string( "WBLRIYRDRRUEDVAZQGUZ" );
        volatile auto OXPGZMNTVU = 697 / 6693 * 1704 * 8441;
        volatile auto XEWNJNZWRX = 7167 | 750 * 1360 + 4778;
        volatile auto BMGLLEUYFK = 'Z' - 'X' - 'I' + UMQQDYQYIE - 'R' - 'L' - 'V' + 'I' + 'M';
        volatile auto LCOTJJIGJR = 7507;
        volatile auto CNVYFEZVFR = std::string( "MZZEYBTFQZEEZMIJBNJIEHJPHRBNJNHSJIZY" ) + std::string( "DSAYVRJFPKWGAFWDRLVQNJNIDOSMKTMRFCKQNJXSYTJKWDUJ" ) + std::string( "YXUVXFBXVFQIODSTADLAUIQRVWV" ) + std::string( "RCWOQDPCSCSUBGUMPHDZBKQGFTUUYJRULQ" ) + std::string( "VJPTDETUOLHLQIWIVEJLXILLWOVIQTHHIIJJFBUFYZXENMHL" );
        volatile auto PTWANYDXPI = APZXYVSUOJ - 'J';
        volatile auto SNLHWLCDEW = LWFQZPAUUK + APZXYVSUOJ - OFRZHMIFRV - LWFQZPAUUK - 'O' + 'H' + 'J' + 'Y';
        volatile auto IICZIKSZPO = std::string( "KCXUMPCGQWWJFKTJRTSCDSGVDCEZRZFQELQDAGFH" ) + std::string( "SEUNSVCQJLCOQRFFTUQILOKOJCEIL" );
        volatile auto JXYHYPVWLE = 'R' + REZYJOHBWB - UMQQDYQYIE - 'T';
    }

    for ( auto i = 0; i < YHVIAWMTOY % 500; ++i )
    {
        if ( FKYDCMVVKN > EJKJDPFIDU )
        {
            volatile auto AZKGDYLXTF = std::string( "SIPZUHRQIYEDFKDVTVHHHNKNJGHANEHQNQGMNGZGA" ) + std::string( "PLEXBPOZQCEQOPODQHMVBGTKZJDGUDJTTQYEBOMRLGJKYUPQK" ) + std::string( "HFNSLXYRJBCVVKVWJLETNVLWNVASPNIQT" ) + INLIVMDWEE + std::string( "ICLIIUYXLTRFPWGCWTLBPG" );
            volatile auto YHCOVDSNTS = ATPYMIKDZK + std::string( "RGSOPIAYAQGUBWTXMTCSFMUPKKG" ) + ATPYMIKDZK + std::string( "YKZUEWXWBFMCDFCXIARGRLJJQIPVMWXY" ) + YOWMFETMPG + std::string( "TMAQEVGBKFHNBETGTMFNELXCLMJRQ" );
            volatile auto FZVNRZXAVJ = std::string( "BCZSBVEJYCSPBXUVAKOXVTHPZNBLPRCFIPZYOFIAE" ) + std::string( "KWHVKSOUSTHAMHLXWGUCNTGFBSZNXRRVCHYSRDDNTGMWGFJS" ) + std::string( "TAWABLXFJTFSDHJGGJYVIGARSATFWHBPJLUSKLUV" ) + std::string( "CYJMAEHARRIBSPJRNQWVODMDWGRN" ) + std::string( "FDUDQWHAKWWGXIOSZLFQTNUORZPEYCYOGXQRUAWHO" );
            volatile auto PTUKIBNZWR = FKYDCMVVKN + UMQQDYQYIE + 'P' - 'Y' - QPTQZHFZVV - OFRZHMIFRV + 'N';
            volatile auto NVZONCHAUZ = 116 - 5030 + 7490 - 8160 | WDGEUPUFYM | 2147 * 7812 / 721 | 402;
            volatile auto JGZDHBQNCP = 2315 * 9898 | REZRNDNQDH / 8982 - 3344 / 2566 - 272 + 9890 * 5961;
            volatile auto DGCGMALZRA = 7711 * 9120 * JXSQIMBTOV | 5930 / 9374 | 4329 - 8134 / 3736 | 6850;
        }
        volatile auto SFMHSMSHDF = 'C' + 'L' + 'L' + 'B' + 'Z' + 'O';
        volatile auto EHUTKWMUUI = 3770 * 1179 - 363 / 8454 | 6955;
        volatile auto LIXNTWIUGY = std::string( "MYIUCITHSSHCUZILOSWNSDAUDBESN" ) + std::string( "VQKFOKZUTRMMMPPJXNRAEBTLIYJI" );
        volatile auto CIPRBSVGSC = 'U' - 'X' - 'F' - FVJAQNYUVJ + 'T' + ZFZZOJWSLS - 'W' - VAKJDLPAIU + 'M';
        volatile auto MOCTEKKXGN = 9383 + AQEDMZTYBL - 7641;
        volatile auto FGMVSVYHZF = std::string( "TWIXNUUVMXZGFQFQODNYBILATJQZKKKZDSMNSNWN" ) + std::string( "FIQQKLIEEEVLBMADMDSYAGAMTQQCARJOLMFQNCBCKJSIQWRI" );
        volatile auto CSAYYIEWUV = 6321 | 8283;
        volatile auto IIFHHEGFOJ = 3304;
        volatile auto ZMMPAABHEU = std::string( "JIFFTQUFIGYJOFXCCPSVFESDBYVJ" ) + std::string( "GVELRWFXZAIHGCCEQCEVULMBCRWCKTBHLBOJAGM" ) + LIXNTWIUGY + std::string( "WVJCJZACMGYBVENTEKPZCWCTDFRMT" ) + std::string( "EPLCTWBVWQLDIQGZTQYDHOJSBVKSYUTFNCV" );
        volatile auto ZHEWQCJBUZ = std::string( "TURZJZWBLDHNAVKOMVUPVDLJAFPNGS" ) + INLIVMDWEE + LPHBNFJOYF + std::string( "QVMDNQIIZEKJVTBTWDVHAGMUKBSPBHCAJQCFBN" ) + std::string( "WZTWPKIRTLXSGRBJZFRWRIVLMUZIFPDBVNKD" ) + INLIVMDWEE + std::string( "TZYWOEHJVKAMDIWWTGYCLEZZHOYZKUKFZTKBXQWYZEFH" ) + std::string( "OAZPZFIYBAVNJYUZCKZCHZRCKYKJENB" );
    }

    volatile auto BYBXSQFDGB = std::string( "GSBWWXSMQHHRGNCFBLXPBUXVCIB" ) + std::string( "JTOFDTKMFLSHRYFEMUGUOVHQMMJTMRCGXVOVMP" ) + std::string( "JGTKBOLYSRJRZNJMKWKJRXAEBRZIMPIKAYIV" ) + std::string( "PRLGPJWMFPIJPCLCJZQBFNZXCJZDA" ) + std::string( "VQYEJKHCTTTKVCCSNEFJS" ) + std::string( "ZKWATTZSBHFSQZOQDQXPHIJJUWVMXMULOKWSFRTLGRREBKROJ" ) + std::string( "MUPMTDFDWKMXMJPRFHKFGDDZNBASFSSLWNTWCRHGLLNJAKX" ) + std::string( "ZSDNYERBAZPTPOZDTUPUZCDVPFXMPEVKFMSPDX" );
    volatile auto ZKYPJKGGRY = 'F' - QKKEGTPDOR - 'G' + QKKEGTPDOR - 'J' + 'A' - 'A';
    volatile auto ODRMEIXJMG = std::string( "REMHRBRKVASWKUQDSLRAKCZSKYKGDCOFTIRVQRLB" ) + std::string( "RMHOETXTRLHTMMCBCUNBAPKJOMDTOTKI" ) + std::string( "TUACOHOAHNKBCXASQEEYAYGIYW" ) + std::string( "BEHEJAYTMDDCYHPOLEUNSDSGOXRGBVXHGF" );
    for ( auto i = 0; i < JQWYQVOOSE % 500; ++i )
    {
        if ( PBGURXDKCV == FVJAQNYUVJ )
        {
            volatile auto MJSRQFVVTS = 'H' - 'X' + 'R' - 'H' + FKYDCMVVKN + 'A';
            volatile auto OJNGDSHEPA = 'N' + 'P' - 'A' + 'Z' + 'A';
            volatile auto IZRCBDQBSO = 'U' - 'T' - 'Z' + ZKYPJKGGRY + 'P';
            volatile auto CPAIVSPDXT = QPTQZHFZVV + 'L';
            volatile auto WXVWYXGPJB = std::string( "NVCJNUNWVUIELDEOVFSDMWALQKTVWBKAWBPDSK" ) + EUTCVXGMJD + std::string( "QURSDARZTJHIKNAWKBNFOVBZ" ) + std::string( "ARAEGYHPFNVTMCCSYZPVTSXZOIBGTR" ) + std::string( "THHTWWKXRSHEPITAPYXBVNXIEVGJROAAHG" ) + std::string( "BMAATARLRFKYOAPBFCRHWJKDIUMSFYNZ" ) + PQIAWXZDJO + std::string( "GLPURYGXOSCWSZNZFSSKVUGUROHRZATRWPOACLHPT" );
            volatile auto SMYWMJQXAV = 4115 - 4376 | 9442 + 8222;
            volatile auto BTXMFKHECV = CVYUUKBCNP + std::string( "YIEHWXGFCZGDISPFYONYWJJMICIWGUHXA" );
            volatile auto AMIIWKQDVZ = 'O' + 'E' + 'F';
            volatile auto XOQJNOUMLI = QMJSNXGLVP + std::string( "OVGFVOYPCYEBQOBLYUCWYXZYNBPCIK" ) + std::string( "YRYRZEUHZPWIKQVHRUZVGRNEPONVHJJDHBZIZWBKIBKUDD" ) + std::string( "CKQYZQGSBIRMIVSOMEGTALXDKLLTENKSEFTQTJCUOKC" ) + std::string( "QNNONEMONXZHCBBVCCMEPINLMYJWTFYRULCDGVOPCV" ) + std::string( "DIZCCPUPVIZHNRYYOHNWBUTCRW" ) + std::string( "SZVNAGLLCTBWAWVSDJOXKGCL" ) + std::string( "OBOTNQFTTHEDETKKYGFTMWJYJABHEKXBQHGQP" );
            volatile auto EMJEJNBRTN = 3649 * 2162 + 9708 | WDGEUPUFYM / XYLNSKGFTU | 3139 | 9074 / XYLNSKGFTU * 7876;
            volatile auto TPTZXAMCXR = 9647 - WDGEUPUFYM - NCWQKDTDNA | ZVIGXWVGAW | 9198;
        }
        volatile auto ZOWSXKPHWV = 'K';
        volatile auto LEAUNJBOLG = NBFECZYGSR + std::string( "TFLUHVIVUSLTNJNLJFBXQKVKPOPUBSIILABAR" ) + GJOYFVRIOU + std::string( "JAETGNTCJDININUDHASWVGRFMDGSRN" ) + QMJSNXGLVP + std::string( "ZCNCJYGCGAKWBNMQVDBDGAWIAB" );
        volatile auto UZVVZEOHDX = ZGWXRTDSHH / 155 | 5975 / 5673;
        volatile auto KBLLIWPBXQ = 'I' + 'V';
        volatile auto SFLEADKLNK = 8398;
        volatile auto FMKENCFQNH = std::string( "SMBIBRWJKODCKUXHRYPAXYNNYFAXIBJQZGAXVTEGARYIVTCTV" ) + std::string( "ZAJEMCEUAMXTIAGAFSEDGBXARWWEGYHJIPBRODI" ) + std::string( "WFTKXDJNPGAOBFOLSYOLBJNFHGYYSLSHNEKEOFDOFP" ) + std::string( "HSNRNCREKUENSAWUKWNVAFLPDIXN" );
        volatile auto TOAFMXMACM = 639 / 7879 - 4934 - JQWYQVOOSE * ZGWXRTDSHH | 6039 - JQWYQVOOSE | 7787;
        volatile auto XZBPAGRJWL = WDGEUPUFYM + 1405 * 5503 - GOOBLABGQI / 507 - JQWYQVOOSE * ZGWXRTDSHH - 2253 - 4316;
        volatile auto RJDEVNOSCW = 4308;
        volatile auto PBKFBXKPSQ = BYBXSQFDGB + std::string( "RWRZHDFNVAIEVGPNRYKNWDXKVDUAUUEIXILQYKO" ) + std::string( "DWZUOZHDEJFSAWAHNUYPHJVEFDMHV" ) + YOWMFETMPG + std::string( "CTLSUZATAVOKNZIACXNNWOJZXGYAZQAHDXFB" ) + std::string( "YJCGLLSNJMUNBATJVHHPTGHNIGBPEHZLCGBPOTWS" ) + PDMOFOONMO + std::string( "XRCPXEKDJCMILVYEVCKPKBOASICPCCBHGNIJ" );
        volatile auto BJPUMPIMIF = WDGEUPUFYM * 5809 + 7171;
        volatile auto XXAQJLGKAG = YOWMFETMPG + std::string( "LZDUPLLWOMNPTEVWKNDTBTCZTFRNRRBMU" ) + std::string( "RJKNNZGRAJSWEBKUYFWLA" ) + std::string( "XCVGAESUVTPNASBFXEZZJBVPKNN" ) + std::string( "ADRFBFMZHFSOMYXXWGFVMQALQJCSKKDQKGYVSVTKYOGMRQX" ) + std::string( "SCUOWBBEFZBEAMVXYJOUZLOURALISVNSMGBHE" ) + std::string( "TNBPMPGNAWWQSMKMISUKOTYYDEOTAXDQGV" ) + std::string( "UWYHBOVOUYAPCLHAMNCTFKXNCZESEOUPVKJH" );
        volatile auto IIBLWYSJSS = SQCDEIFOJD + NBFECZYGSR + std::string( "KXVULXDVAPXHQCRHTSVFNSJD" ) + std::string( "IMKABVGCOQBMAWPYMSQSOSINBWKESRUT" ) + std::string( "UXJGNGYTUGWWPDXZEKBJWWIZTYJQROYFHDOQR" );
        volatile auto AMRKJCLVZI = std::string( "DZVXNENLUGHTDTCDAQDFRSVFAAFZLFDECASINRTAIDV" ) + std::string( "KEQXMYOZPDDRCBUQJXCWOXH" ) + LEAUNJBOLG + std::string( "UDFLYBJGKJWMFUONWNPZZT" ) + std::string( "BKRVEGESJCCGQRIUHIEHCBPPBRVEMUPHVGTDVBJIUHJLNDQOW" ) + std::string( "LAGPMVKKYFYFZVMVRDCYBHHMKEVLJSITHX" );
        volatile auto TZSTFPQADL = 9452 + REZRNDNQDH + 7139 / 6584 + 5263 * 2769 * 8930 | 8932;
        volatile auto RBYKLOMLVT = ZGWXRTDSHH / 5940 * 8308 | 4320 - 2194 * 1127;
    }

    volatile auto SCXQBONACZ = 'C' + QKKEGTPDOR + FKYDCMVVKN - 'P' - 'F';
    volatile auto XORUBGMIHY = QKKEGTPDOR + 'S' - 'Y' + 'Q' - QPTQZHFZVV + QKKEGTPDOR + QKKEGTPDOR + 'C' + 'W';
    volatile auto NIJMOAYMAV = 5295 + 6321 | 3584 - 2016 | 1845;
    for ( auto i = 0; i < YABJBLXHVT % 500; ++i )
    {
        volatile auto KEMFVXKYJZ = 'J' - 'Y' + 'Z';
        volatile auto XLDJHPWKCO = XXLTDVTBKW + 2988 / 6226 | 1723 | 9575;
        volatile auto WYJOQJGJJB = 'R' + 'H';
        if ( YOWMFETMPG == LZAJUTHAWP )
        {
            volatile auto MDABHOBCAE = EKQPFVBSVF + 'E' + 'G' - 'K' - ZKYPJKGGRY + 'T' + BRLBUDUKKM - 'H' + 'Q';
            volatile auto AQQRMWCELD = PDMOFOONMO + std::string( "WFNNDHOHTYHYSTSRJKAHH" );
            volatile auto UOGJBCOPGT = 'T' + EKQPFVBSVF + 'K';
            volatile auto ADHZTSACAB = INLIVMDWEE + KCKLUFWXQE + BYBXSQFDGB + GJOYFVRIOU + LZAJUTHAWP + std::string( "OZJIGTAYLTCUOQRMLJLDBOZZRFTKZYLXMJGDANIV" ) + LZAJUTHAWP + std::string( "KQAZPYNHEIFKNLXAQZTV" ) + std::string( "SGCPWIVNJGWANEISSSJVKXE" );
            volatile auto EYLCEGSFMD = XETDUJHWDF + std::string( "MRBNWYPYJDNHKBYNFGZAPT" );
            volatile auto BRPQDHNCGU = LWFQZPAUUK - 'S';
            volatile auto TJNYVGAIFV = RPXQIFHURU + 'H';
            volatile auto OUBRQVELBT = std::string( "AVNEOMXMAIOHBEXYLOSLMPEUDRPBUTWVFJQORBF" ) + ATPYMIKDZK + EUTCVXGMJD + std::string( "JJOHERSOCJZSOXWMPFGWZAHHHQRZ" ) + std::string( "ZDYNWDDIQGNLHMHJCGZOATBESYTPLGRGGNXVCUKEM" ) + std::string( "LSFBTVYKOXJOGFTOLHIWVBRKVUNEF" ) + std::string( "UYLZRDZZZFVFRNJAVGZHTEPNQLIKYXSYJ" ) + std::string( "MLLLVVNIQSQIXIGVOBCMWWHMGTLCJTOYWAD" ) + std::string( "JBXUZDEGRQEYECKKZWDSMXFGZPZAIGDPCLKJFOULTPJN" );
            volatile auto UQWOSIMWQV = 'R' + 'P';
            volatile auto CYMOSLHPRY = PBGURXDKCV + UOGJBCOPGT - 'U';
            volatile auto RUOQTQKIEP = 'K' + 'N';
        }
        volatile auto LLHINYUTOY = 4631 * 6622 / 7481 * 3321;
        volatile auto NKJQRUDMUT = ZGWXRTDSHH | 2821 | 2675 - 8702 + 6315 - 7163 * 1218 + 145;
        volatile auto NGSZETZTIW = ODITAAFUXP - 'Z' - 'P' + 'A' - ZKYPJKGGRY - ZKYPJKGGRY - XORUBGMIHY + UKPCRHZFOF + 'Z';
    }

    volatile auto MQWKZCJPDE = std::string( "RMBQDKKJKIYJJCEINTUIXPZIHH" ) + std::string( "XSUDFPPUOHPPYDGQICNS" ) + std::string( "QNWCOTKJSNSOIHSJFNDHAZRADHQLUDOSOXYLHDCP" ) + std::string( "SLRQVVYGCYPPYAALJHCBKOPWZVWCDLJJWVZCGHPLF" ) + std::string( "FIEVURZZVDQOGTDAXEBRQWPBWIPYTC" ) + std::string( "MJSVEIQTDCOUDSISCYLBBFTSAZFCQFQSLBDMW" );
    volatile auto ZFQZWVMHIU = 4774 + 7756 / IAOTYUQDPQ / 1142;
    volatile auto MLTMXWCPNT = 9420 + 2922 + 7157 / YHVIAWMTOY / 8854 - 7439 - MNOTXXRXQM + 1480;
    volatile auto VOIZEBPNFJ = 'Q' + QKKEGTPDOR + LWFQZPAUUK - 'O' + 'I' + 'E' - 'N';
    volatile auto SVUDGLEQRY = std::string( "JKAQEMAGYXKXONMLQDODOAKBZYLFQO" ) + PQIAWXZDJO + std::string( "BLAYKAUJAZQFBVQKQITWTMSNWHJV" );
    volatile auto WSEDFOIRDY = std::string( "PNMBHNMZUPNSNIGSBWKTLGDVMGCGGV" ) + LZAJUTHAWP + std::string( "GSXJKRPALFTZPWLJABTIVHQMTHKEZICGCLKO" );
    for ( auto i = 0; i < 7189 % 500; ++i )
    {
        volatile auto KSYCKPDHKB = 6883 | 7453;
        volatile auto IRATYOURQD = std::string( "GACGKWCATYOORYBQDLTBMOVHGWZGNLUG" ) + std::string( "AYSZAHMDCRYSEUZOWVNHEHVBEOOWRGDBBZHIEAGGYQEBS" ) + std::string( "CRULSQMWNXQFMRJWPGINDUICGGPLPBDVHPFNGUNIE" );
        volatile auto KCUPVUMRWE = INLIVMDWEE + EUTCVXGMJD + std::string( "ORBGRSEVGNCZPWQQXOCIGWKONAHTOCSTKYOHCLGEPYUGXCL" ) + CELATXBNOV + GJOYFVRIOU + std::string( "RLPDZTCYZZHVAPSPSERRLNOVV" );
        volatile auto MVSIRCVGBI = 'R' + 'Y' + 'M' + EJKJDPFIDU + 'O';
        volatile auto JILFGFVVNT = 8357;
        volatile auto FJWCBGVRCA = 997;
        for ( auto i = 0; i < GOOBLABGQI % 500; ++i )
        {
            volatile auto MXDEZLZKRX = 6710 - IAOTYUQDPQ - 3339;
            volatile auto IKEUELSULA = LZAJUTHAWP + std::string( "PENWOQZICKQBCAYDCBATVGLWZZTEVHVBIKMTOLPPYLB" ) + std::string( "YJSQWOWUNVPPTSOEORLLVKFYYQCMV" );
            volatile auto PZLDAXOBSD = 'D' - 'L' - 'B';
            volatile auto NPYOMWZGFI = 'H' + OFRZHMIFRV - 'B';
            volatile auto NOHRPHQSVO = std::string( "KMBMSJTKMOBKHFPWMFHRZWOQSWWDVNNSFQCTQFGI" ) + std::string( "OASOYLUVNPOZAJFQCWGHYYJOAEIYNKCJ" ) + std::string( "WWIYOSJFFMMPQDNUDWHCNEEYFASOBBWNDQSEVJJUB" ) + std::string( "DSFRRKSOAVDEPYLALJYTMMBPAWIQMXMBZHKL" );
            volatile auto LRVUFTASRD = LWFQZPAUUK - 'H' - 'E' - 'U';
            volatile auto PTQXSVKDDW = SCXQBONACZ - 'W' - XORUBGMIHY + 'A' - RPXQIFHURU - 'W' + ZFZZOJWSLS - 'L';
            volatile auto NXKELBRJVR = 'J' + QPTQZHFZVV - 'K' + REZYJOHBWB - SCXQBONACZ - APZXYVSUOJ - 'C' + 'C' + 'E';
        }
        volatile auto CKCPWGMZFG = 4411 * XYLNSKGFTU * 1111 + 1460 * HLNJGVFHOT * 7644 + GOOBLABGQI + 3175;
        volatile auto WGOFNFTGCB = std::string( "NRSNNVKCHYHEVRUTOFPKVQZGAAEGIKHKRECDTLMILECCYX" );
    }

    for ( auto i = 0; i < 1396 % 500; ++i )
    {
        volatile auto QWMRPQZDTH = BYBXSQFDGB + std::string( "IRTEYXDACTUOBFCIXSDDQHBHAEUPNOQLNCWP" ) + std::string( "SIFVFYYBPMEUDNNNCJBYJMQWYOUNNJRTXGX" ) + std::string( "LVPGQFGHEFSJWRELOGUKWWQHFIEMUPMLZZCZXHTMMQCRMZXOJ" );
        volatile auto KMCPEHAHBU = std::string( "WFMTXLRKGYGXAALYACYFCFAPRKQYWKOYYARPCMNZBSHZZS" ) + std::string( "CNUTOVKHYAJWVOOZDKYBPZKREPMLUPGBKFKAEHELPRTYPXL" ) + std::string( "YIYMJUILQDOVWFMLYFLCHDDXQKWJGXGXATFD" ) + std::string( "FRJXRAGVFAWZYYFSXQUDAJUT" ) + std::string( "ONJGZMKYQHLGIGCIJPFEVXQCK" );
        volatile auto HCQYGTQFNK = 'V' - 'N' - 'T' + 'H' + 'U' - 'H';
        for ( auto i = 0; i < KLXECPMESL % 500; ++i )
        {
            volatile auto QPNLVAWQBK = 330 * 1541 / 6118;
        }
        volatile auto PPPBTKXSTT = 'F' + 'R' + 'I' - 'I';
        volatile auto RYMMTQPDBX = CELATXBNOV + std::string( "DCKECIJXJTFVCOBCUEEGOJLH" ) + std::string( "FRZKSSBZAHOBTNBKNZPUR" ) + EUTCVXGMJD + std::string( "OVHLGCPLPQKVRAASJDWBPQZDMZLDASQYFTKUMFVSIJ" ) + std::string( "DXVEZHQMLWALQXQGGEHETGEX" ) + std::string( "MYIFOBWXPBBALEEBMMBKXTXNEQAUTUCTNHDHYY" );
        volatile auto IOVOUELNPP = std::string( "TWGHAJRMCQTEEOZURLLVZPGFQ" ) + std::string( "SBLFPRCBIRKWHJFIRZFDQBQKS" );
    }

    volatile auto ZMUCUCPAGG = std::string( "CBXTQUFMEATSEWUMUPBVHTHQZHRDKTUPVENJMLZYHULISASTQ" ) + std::string( "CBKFEWAJLAIPDNNIZYZPXMRW" ) + LPHBNFJOYF + std::string( "IEAUHUTGPJOBKXOFVTRZJITHWKVYMGYIDCPIDVYX" ) + std::string( "WBIAKTXWZVTILFYIHGBZUTDVSKVUHOVHVZLCTPXKXCXATHYHD" ) + std::string( "XDPKAMMLTVOSIQBSVCBK" );
    volatile auto MPYDKUIEGG = 'N' - 'J' + 'T' + 'U' - 'D';
    for ( auto i = 0; i < 8695 % 500; ++i )
    {
        volatile auto TCHIHOCCBZ = 'D' + FVJAQNYUVJ - FKYDCMVVKN - 'K' - 'H' - 'A';
        volatile auto TUVFGUKEUZ = std::string( "TWRBVPSTMNXBZYFHSMVWJQAMEANZJKS" ) + std::string( "LDYZIHKJTUBADWEXUCSKBUMIXIRNQBNLCTOIGAFSYBYQRA" ) + std::string( "CZPWTSGQXJHVQTXALZVVRWVAZKKJTHXYRPYFDC" ) + std::string( "SKWVVYFEPXIHXWQMJEAVSWJROKQ" );
        volatile auto GVOCBXBDVR = 'N';
    }

    if ( HLNJGVFHOT != 4574 )
    {
        volatile auto QSHNNFWWXK = std::string( "TVMDOQTAKGXMCAGPHALSVSLHDDTRFHGITQUN" ) + std::string( "NBXISKSBKEALWBUCZOSLGTC" ) + SVUDGLEQRY + std::string( "YSDIAFUUBBCLVHWUYQYXNTNBWLAFXQ" ) + std::string( "CXMGWSCTJFUARUFFBLOE" );
        if ( ZFZZOJWSLS == 'P' )
        {
            volatile auto OIRZLFMCEJ = YABJBLXHVT - 4417 - 2132;
            volatile auto PBJKNUMGYD = 'F' - 'P' - VOIZEBPNFJ - 'S' + JPSFJHMKNJ - ODITAAFUXP + UKPCRHZFOF - 'X' - 'N';
            volatile auto AWJZOMAGNI = 5138 / IAOTYUQDPQ * 252 | ZFQZWVMHIU - 9064 - 8561 + RBPYUQHIWU - 1031 | 1272;
            volatile auto KHAFKDVZYA = 4930 - 2496 - XYLNSKGFTU * 2811 * 1179 / 4665 | ZFQZWVMHIU / AQEDMZTYBL + 6157;
        }
        volatile auto QMZVTXFLRS = std::string( "ZZHMCCMHVGFSVFTEKIPMMLFARSWAEO" ) + ODRMEIXJMG + std::string( "SOBNGSOKMTWOTGUKGMCHCMWJIZXIWXSS" );
        volatile auto DQITMZTGCP = 7165;
        volatile auto GNPBDOZZRT = GJOYFVRIOU + std::string( "YXKLXVZXMZNZYDWOMMJIZNCLMU" ) + std::string( "GWDWAYRWVDBARBJZGKUZZCNUPRMJI" ) + std::string( "PYEDIELUQSZEVIDJIHJLHOVKDGMVXUDXPFJEIRGMAP" ) + std::string( "LBCUZCRQXWPBOPZZAQAWKSWPQLHRSTXHUWUHBOSEUJ" ) + std::string( "ITFNDOUAXDZIHSVRYMYWCAAAYZG" ) + std::string( "LEJULOVIKLOEDQIYEISFPDHXFHNIVTFUPLA" );
        volatile auto OMEPOVIQNZ = ZFQZWVMHIU - YBNUMWGPPZ / YHVIAWMTOY | 199 | 275;
        volatile auto SWATKKRBXP = 'L';
        volatile auto NMGGFHVFXR = 'G';
        volatile auto OALDTZXFVQ = std::string( "OAWGFONATHUKHZOVLASFJXZDDIBRAP" );
        volatile auto QCWKADVLDJ = 'S' + 'L' + 'Q' + 'D' - 'S' + 'H';
        volatile auto PFCHVMEBEB = 'R' - 'V' + 'D' - 'D' - 'X' + APZXYVSUOJ - 'M' - 'T' - 'K';
        volatile auto VUCBBGOTWP = EUTCVXGMJD + std::string( "AVQNTYHCRAICZUDVYFHKGA" ) + std::string( "TTURDATRIXAPNEOEOLIXWZOIDGZRV" ) + std::string( "ORKHTZUBDHBAJMUELNXACWNKAVWEEDHJBGHHDAJH" ) + NPFKHHVZOD + std::string( "SEZHYCPXAARYDFMBKEPVMEZYAKSXZNOEVRPDE" ) + std::string( "EEOPKCNFBHOJSXMLMDMPJXRUKGUNLEZCTDVJAPKPCXD" ) + std::string( "HNTFEIZTWHLQOCDLXSXNLTEYOJZJKWBH" ) + std::string( "EKEISAQKFYVZNIVQUJPIAGDGWOH" );
        volatile auto QKGNANKBGI = 'F' - ZKYPJKGGRY - 'H' + 'Z';
        volatile auto HMQDPINABC = 2119;
        volatile auto RDVPNIRFAU = std::string( "BOAUPBDIBXPSVEYOFNTLAORGGAPBQMMQADCD" ) + std::string( "LKYFVKNMWUNPLBSPKZRSCUYEWLBRZEQM" ) + ELQEWKBUSO + NBFECZYGSR + std::string( "CQCBIQLTIJIWNSDBIHLM" ) + std::string( "UAZCAJGVZTUYKGTCOSLTPWDZZMAYWCJCNUOVN" );
        volatile auto BLLSFETVJJ = std::string( "GJVESMTMXAUBYBNAKXSVCGBPBCREDIAZCM" ) + ZMUCUCPAGG + std::string( "TJAHGDPVPIOZVZLULHGVTZG" ) + std::string( "CGVMAMEGNBTNCBZAMWRKTDKYZEAWWY" ) + std::string( "TSOPTWNZSWJWMPZVXNWLHJOSIPMSKKSQIVAKV" );
        volatile auto NXEBZPMAJS = 1855 - 5054 * 5268;
        volatile auto ACXTJWXGAU = RDVPNIRFAU + std::string( "MHDTXRMKROVEVWUASWTWVWAJBUNLT" ) + std::string( "OFHAPGOTSPDPHDMQHTSCDARMMROZITNABCIQOZU" );
        volatile auto TECMWMKXUT = std::string( "QAAAHBEPATIVDTFAMKJAEJ" ) + CVYUUKBCNP + PDMOFOONMO + std::string( "PCTRCOXGALPGDQDLRCYJGPRTOLFDR" ) + YOWMFETMPG + NPFKHHVZOD + std::string( "CAKACQITPUKVWNRTQHXPMZYUOARB" );
        volatile auto PBDNYZUINA = 924 / 9798 + 3712 * YHVIAWMTOY | 3051 / 6170 * 4934;
        volatile auto APOJBVRCHZ = std::string( "MPUVHYRVDTRHRAGIBJGLCHGHCXZQVXGYBMK" ) + ELQEWKBUSO + std::string( "CGPNDLFJNTKZAAFMTGEQDLL" );
        volatile auto SEGNXRCNSR = NMGGFHVFXR - 'U' - ODITAAFUXP + 'D';
        volatile auto OHLHJGTMZR = 5897 + 4517 + 1303 - ZGWXRTDSHH / 4143;
        volatile auto LHYEABQWQB = ACXTJWXGAU + std::string( "FWQKJWZRQOJSQNQFLCTJKW" ) + YOWMFETMPG + std::string( "BEIIAPLAGKIQMPURIRFWTMSDHWUVWZEZLOSF" ) + INLIVMDWEE + NPFKHHVZOD + std::string( "WPPUNKUDIUXOSUTUUJYJSESXNAZMLXRWNGCNNKHQIRGRHMMB" ) + std::string( "LHRKDBALRFHJCIBAYBPAOYQCLULSAKRVETE" ) + std::string( "UCTETVBGZNRPYIPHLHOLFI" );
        volatile auto DMJONOZAJZ = 1674 / JQWYQVOOSE | 3388 / 2765 - 5329 * HMQDPINABC + YBNUMWGPPZ | NCWQKDTDNA + 6555;
    }

    volatile auto UZKIOYAMLY = NIJMOAYMAV - NCWQKDTDNA / 1452 / 3181 + 8474 / MLTMXWCPNT - 3246 - 3428;
    if ( BXZEPJZRVR < XXLTDVTBKW )
    {
        volatile auto ONMHNPIFLU = std::string( "SZRNPPCMFWVBXKUCMOLQOKOKDSJFWXBPBQRMJATSRGLFRC" );
        volatile auto WXCLLIHLHK = 'S' - QPTQZHFZVV - 'H';
        volatile auto QWMUQDKLCB = 4861;
    }

    volatile auto WAKZJIPVYG = 2674 / 560 + 1498 + JQWYQVOOSE - 9565 | 5067;
    volatile auto VLITINAURX = 'S' - 'W' - 'J' - 'E';
    if ( HLNJGVFHOT < 7716 )
    {
        if ( QMJSNXGLVP == std::string( "KGEJGROVHASUIQJVDYRKYBOZMZZREJOHEATUPFIRLCSODPIFL" ) )
        {
            volatile auto AWCBIREXGR = 8294 / 9658 - UZKIOYAMLY | 8541 | MLTMXWCPNT + 3746;
            volatile auto ZHEPXTLKDG = 4345;
            volatile auto OJRHSLQPAB = std::string( "SZLRJRNDLKGFQTQMDVTXEPZMHGJLZFND" );
            volatile auto XYYRZHYVRW = 'D' + 'O';
            volatile auto PGTHPWBABZ = std::string( "CKMDMVCEALOULRRDWFPCMIEPTXEYUXUWAWTTNG" );
            volatile auto XIPQBMXEZF = BRLBUDUKKM - 'Y' - 'U' - 'H' - VLITINAURX - 'W' + SCXQBONACZ - 'B' + 'D';
            volatile auto YZUMEAAZWL = 'Y' - 'D' - 'T';
        }
        volatile auto XLDYLOJKKC = WSEDFOIRDY + std::string( "HUVZNISEQPVTHLHKXZNTHEBHHOSQARDNGFHURAQXQOICKKB" ) + std::string( "YQCDYMIMBDMSXJQDSWYXWMBXJOHIAPEBDIRHNKJQ" ) + INLIVMDWEE + std::string( "MOFUKEAMLZKOORIPHMIWZLNQKIVTWRXHNNFSIQYLBLPN" ) + std::string( "APKBIGPTCDAAMQHRNWUN" ) + std::string( "RERTGXDVWVLRJQHPGYGOZIEAUKJGSGRZIHIIYOLQTY" ) + std::string( "TJAQYVNWCPELJCHZQSNPVARDLQU" ) + std::string( "PPCWWBWDUOUVHKPGLTSWFHAFKHLPH" );
        volatile auto RJCYNYEPHI = 5872 | 6563 / 7664;
        volatile auto QUBGGVIQMP = 'F';
        volatile auto UXPKXEKWRL = std::string( "MNQRHELPNKRMUQHECCHOJBOGGIEHIX" ) + XLDYLOJKKC + RALTXIJWCL + EUTCVXGMJD + std::string( "GYLZKLZAEGPFOIQQBATZKNWXIZSCSKGABOXF" ) + std::string( "EPVUBEEDTBNRKSWHTAOEZKKCVGVUNQQJHIONXPFW" );
        volatile auto EAOIFHPDFZ = YABJBLXHVT * 6944 - 3739 - 8425 | WAKZJIPVYG + 8793 - 3987;
        volatile auto GCSPOTMABW = 'Q' + UMQQDYQYIE - 'V';
        volatile auto ZZOSZZZCCZ = ATPYMIKDZK + std::string( "TKVAURYQGXRIAXSPYEEMMOP" ) + NPFKHHVZOD + std::string( "PHUXAXOCQFVORFISFUJLBJJRHRYAFOLZQRYBLNLQR" ) + PQIAWXZDJO + std::string( "XBUWYZHHGRITTVJBLNCYFPWCSKASEIYCRDIY" ) + std::string( "WVRBHZIHESDNZODXTFBPNLOCSMGSGWBGYEWJQWVSVATV" ) + std::string( "KHPJUTPBIQXPURUHWKJUNRSWLVBI" );
        volatile auto UCXLBANAYF = 7440 + 2474 | XYLNSKGFTU * NCWQKDTDNA | 6979;
        volatile auto BHXRTUGFZF = PBGURXDKCV + 'N' + 'N' - 'J' + ZFZZOJWSLS + UMQQDYQYIE + 'R' + 'T';
        volatile auto XIVHLJVURC = 8942 + 7445 * 1991 / 3763 | 4687 + JQWYQVOOSE * 7671 - 6668 + 3442;
    }

    volatile auto GVFCGKTSLI = 3832;
    volatile auto MLHOSBKPSD = MNOTXXRXQM * 4319 / 952;
    volatile auto LCULSDWQEE = 'S';
    volatile auto DKWRUPFBZI = XYLNSKGFTU + 3031 | 9197 * 3034 + JXSQIMBTOV + 6422;
    volatile auto RGIHMZVAHS = 'X' + 'M';
    volatile auto CNNXKDTBXU = 'J' - 'R' - 'J' - 'S' + 'J' + 'G' + ZKYPJKGGRY - 'C';
    if ( QMJSNXGLVP == std::string( "JHKDKCBAXEEETFOLFKTGZZSSGBSR" ) )
    {
        volatile auto KRDYKRMAOP = DGKHDEOHEZ - DGKHDEOHEZ - REZYJOHBWB - 'B' + 'A' - 'D' + 'A';
        volatile auto PFCEAXWGUO = 'A' - 'V' + 'N' + OFRZHMIFRV + 'S' + 'W' - 'G';
        volatile auto QIPKRNCBXR = 'O' - 'E' + 'C' + 'A';
        volatile auto IRNKONZBII = std::string( "SDDDVKCGCHOWIISQORPYXN" ) + std::string( "NSFJVIBEELPDQOAMMGRRFFQNPQRMDJDSVIVALFVGWSIBAKPFP" ) + std::string( "ROBUHWHHSABGKKUMWONFBLXMEF" );
        volatile auto NYTMQPIRNT = 'N' + 'C';
        volatile auto VMVJVJCTYI = PDMOFOONMO + std::string( "FCEVPJLMIUPNIPGQNBKLSJRCWYIGL" ) + std::string( "JJZLGLXVKTLBUPVLBYRBEATPOQDZEDNBTYJ" ) + PDMOFOONMO + std::string( "QLBIPJIPKWPIYRHGJHWGVTKHDRSAYVPONFNRLTDOALH" );
        volatile auto LUSOKRFJYX = 8083 + DKWRUPFBZI * 8978 * 6875 + 2286 * 2029 | 1098;
        volatile auto QNRZTHGSGN = RALTXIJWCL + std::string( "YSZFGQWDVWUOUKMHDOSKTTQ" );
        volatile auto GCJVUVXIUU = 2596 / 9859 * 9176 + 5874 + 3633 * 1455 * 4312;
        if ( QMJSNXGLVP == std::string( "ABBCNXHYVLAVJUFFPGHLJYSXPYLFVSHNFLAZYQ" ) )
        {
            volatile auto XIOUYUVUYI = ZVIGXWVGAW - 3757 * YHVIAWMTOY / 5956 + 1850 / ZFQZWVMHIU / 9984 / 6721 * 303;
            volatile auto ZMVSLZOEWO = std::string( "WVCCXTLJPXWVYLSEIYLGRUBOXZHRIXZNXMGFAEYBBZHKITTRH" ) + std::string( "TASXIYLFMEEAJESMQGDFPKTIXLKEELMZA" ) + std::string( "CSIQPDHBSWIHKAWOHBBRFZTVTXDGIXD" ) + std::string( "TAQFMDHBLTTECZMWRZBTVSRYLFDM" ) + std::string( "AVSWPUSUPRXIEDMBISTGZVI" ) + std::string( "AAUJRNJWCOKGEFXNKZLCFNTWGXHUXWZAGLMANICSQ" ) + std::string( "VNMHYCTGOYFPJASTXZBWSLHHIGFFCRTNAELYZTOGJMBZB" ) + std::string( "FYRXNDXERPFPUUDKVNFJHGNBDG" ) + std::string( "IVJEUJFAMEQBTNOXZYZLQUHLLPNRFNCAJNMSWFMWHAQBBKV" );
            volatile auto BTUJHONXTF = 1624 * UZKIOYAMLY | 2708 / 2888 + 6883;
            volatile auto SZBRBIFBLJ = 'Y' - 'V' + 'I';
            volatile auto JRXXLNSPQJ = ZKYPJKGGRY - LWFQZPAUUK + 'G' + 'V' + 'E' - 'A' + 'V' + 'J' - 'L';
            volatile auto KIABMKNHGF = std::string( "WKMIDXTTXKNACFEMXTHDFHXJPHSTDLHGZMVZKPUUMEKSEIT" );
            volatile auto CMSOMCSWEZ = ZGWXRTDSHH + 8955 + 4966 / 8431 | 8192;
            volatile auto DRUMAXDMXP = std::string( "PXSPLLBLDTQAVMGAQFLIFWYXSPSAOLNZJFFWP" ) + KIABMKNHGF + std::string( "WSGQRQHKKLPOBRIAJYTP" ) + std::string( "FFRWRYCEWUPHCXDSKXLYCDEHZLCMUVMPDWIWZLIKVO" ) + std::string( "QCAKWGWPKAIZDFOGTYOBDNKCHOSKLQ" ) + std::string( "ESTAINCUKDLHFDRXDIOLETIWTI" ) + std::string( "GGEIQGPAYOCOYLHNDBLKXGZOUKFUYV" );
            volatile auto OWBKDNMSVV = std::string( "OECEWVIIYQJPAWLIOCCQVKXGSJIKGMTHST" ) + IRNKONZBII + ZMVSLZOEWO + std::string( "BMWBWGSONGFYLSMVNLOJGIOYQPBBOZVKQGAMERKOGPKQPTQ" ) + std::string( "HFQANLVIFRARWBACQYXIWYBKCRUMLOHOF" ) + ATPYMIKDZK + std::string( "DGXWQIWQJMLQXRMBBSNKNTUIFVPKN" ) + std::string( "UZEIVBGOZTHCEUKMORVSLDWXWZCLDJBDAVTUQ" ) + std::string( "UXDITUDQCGLVYULQRECI" );
        }
        volatile auto IQPDQJNCRG = XYLNSKGFTU - 117 / 9415 * 613 * 7168 | 2220 * 8973;
        volatile auto UFDCMYFSMP = JXSQIMBTOV + 8726 * 6179;
        volatile auto EZUTYNJKWS = 284;
    }

    if ( HLNJGVFHOT != 3283 )
    {
        volatile auto JSYSVZIBQD = 8128 | 1962 | 7792 * 7264 | HLNJGVFHOT | 5655 * WDGEUPUFYM * 3960;
        volatile auto WVXIXRWMWH = 'W' - 'J' - 'L' + OFRZHMIFRV - FKYDCMVVKN + 'H' + 'V';
        for ( auto i = 0; i < BXZEPJZRVR % 500; ++i )
        {
            volatile auto CBXYGZESAD = std::string( "ZCHHYKUYSAZOTNIINTUILZPPNMABLFZVGJXVIWUMJZAI" ) + RALTXIJWCL + ODRMEIXJMG + std::string( "ZMYHJHOFNPMIABAWJRDIBPLNICYO" ) + WSEDFOIRDY + XETDUJHWDF + std::string( "INQFJBKZGJABMTKPMVDUDJQL" );
            volatile auto MQYRFLXNOB = 'K' - 'R' + 'O' - 'S' - 'U' - 'C' - CNNXKDTBXU - 'W';
            volatile auto VYKFKNBQCS = 'E' + 'M' + 'A';
            volatile auto NAETYFAAPC = 'E' - CNNXKDTBXU + 'V';
            volatile auto RVWIKKRFUY = FKYDCMVVKN - 'M' + 'O' - 'V' - 'C' - 'O';
            volatile auto KFLCXNUWIJ = WVXIXRWMWH + 'W' + 'F';
            volatile auto AYXQUNVRDQ = 65 * 7999 * 6216 | 7630 + 1325 - 3976;
            volatile auto BEJJNFHLZC = 1404;
        }
        volatile auto XLXRMIGLEV = 2910 | NIJMOAYMAV + 795 - 1519;
        volatile auto GINMCOHAGE = PDMOFOONMO + WSEDFOIRDY + std::string( "OVNOETSSARWJBVSTHQCJXPHKYVSOJT" ) + std::string( "VFCWLBHABSSMLYOCPIBDIGISFN" ) + std::string( "KRGJSQLSDCWOJDVKXOXJQYF" ) + std::string( "YKXYNRHNJSLOZAKLUFEYLLLGMABYBJXJUW" );
        volatile auto ZBGCDPMNIR = 'M';
        volatile auto ZVCUDVZZVE = 'Z' + 'O' - 'H' - ODITAAFUXP + XORUBGMIHY - UKPCRHZFOF - ODITAAFUXP + 'E';
        volatile auto UQRJITYJRL = SCXQBONACZ + 'J';
    }

    volatile auto RQIOAFMEQE = 7904 + XYLNSKGFTU / 2373 + 2801 / 36 * XXLTDVTBKW + 5066 | 988 + 8400;
    return 'P';
}