Go back to Richel Bilderbeek's homepage.

Go back to Richel Bilderbeek's C++ page.

 

 

 

 

 

(C++) inline versus non-inline

 

InlineVersusNonInline is a simple benchmark to compare inlined with non-inlined functions.

 

 

 

 

 

 

Technical facts

 

Application type(s)

Operating system(s) or programming environment(s)

IDE(s):

Project type:

C++ standard:

Compiler(s):

Libraries used:

 

 

 

 

 

Qt project file: CppInlineVersusNonInline.pro

 

TEMPLATE = app
CONFIG += console
CONFIG -= qt
QMAKE_CXXFLAGS += -std=c++11
SOURCES += main.cpp


 

 

 

 

 

main.cpp

 

#include <boost/timer.hpp>

inline int InlineAA(const int x) { return ((std::rand() % 2) ? 1  : 2) +  x; }
inline int InlineAB(const int x) { return ((std::rand() % 2) ? InlineAA(x) : InlineAA(x)) +  2; }
inline int InlineAC(const int x) { return ((std::rand() % 2) ? InlineAB(x) : InlineAA(x)) + 2; }
inline int InlineAD(const int x) { return ((std::rand() % 2) ? InlineAC(x) : InlineAB(x)) + 2; }
inline int InlineAE(const int x) { return ((std::rand() % 2) ? InlineAD(x) : InlineAC(x)) + 2; }
inline int InlineAF(const int x) { return ((std::rand() % 2) ? InlineAE(x) : InlineAD(x)) + 2; }
inline int InlineAG(const int x) { return ((std::rand() % 2) ? InlineAF(x) : InlineAE(x)) + 2; }
inline int InlineAH(const int x) { return ((std::rand() % 2) ? InlineAG(x) : InlineAF(x)) + 2; }
inline int InlineAI(const int x) { return ((std::rand() % 2) ? InlineAH(x) : InlineAG(x)) + 2; }
inline int InlineAJ(const int x) { return ((std::rand() % 2) ? InlineAI(x) : InlineAH(x)) + 2; }
inline int InlineAK(const int x) { return ((std::rand() % 2) ? InlineAJ(x) : InlineAI(x)) + 2; }
inline int InlineAL(const int x) { return ((std::rand() % 2) ? InlineAK(x) : InlineAJ(x)) + 2; }
inline int InlineAM(const int x) { return ((std::rand() % 2) ? InlineAL(x) : InlineAK(x)) + 2; }
inline int InlineAN(const int x) { return ((std::rand() % 2) ? InlineAM(x) : InlineAL(x)) + 2; }
inline int InlineAO(const int x) { return ((std::rand() % 2) ? InlineAN(x) : InlineAM(x)) + 2; }
inline int InlineAP(const int x) { return ((std::rand() % 2) ? InlineAO(x) : InlineAN(x)) + 2; }
inline int InlineAQ(const int x) { return ((std::rand() % 2) ? InlineAP(x) : InlineAO(x)) + 2; }
inline int InlineAR(const int x) { return ((std::rand() % 2) ? InlineAQ(x) : InlineAP(x)) + 2; }
inline int InlineAS(const int x) { return ((std::rand() % 2) ? InlineAR(x) : InlineAQ(x)) + 2; }
inline int InlineAT(const int x) { return ((std::rand() % 2) ? InlineAS(x) : InlineAR(x)) + 2; }
inline int InlineAU(const int x) { return ((std::rand() % 2) ? InlineAT(x) : InlineAS(x)) + 2; }
inline int InlineAV(const int x) { return ((std::rand() % 2) ? InlineAU(x) : InlineAT(x)) + 2; }
inline int InlineAW(const int x) { return ((std::rand() % 2) ? InlineAV(x) : InlineAU(x)) + 2; }
inline int InlineAX(const int x) { return ((std::rand() % 2) ? InlineAW(x) : InlineAV(x)) + 2; }
inline int InlineAY(const int x) { return ((std::rand() % 2) ? InlineAX(x) : InlineAW(x)) + 2; }
inline int InlineAZ(const int x) { return ((std::rand() % 2) ? InlineAY(x) : InlineAX(x)) + 2; }
inline int InlineBA(const int x) { return ((std::rand() % 2) ? InlineAZ(x) : InlineAY(x)) + 2; }
inline int InlineBB(const int x) { return ((std::rand() % 2) ? InlineBA(x) : InlineAZ(x)) + 2; }
inline int InlineBC(const int x) { return ((std::rand() % 2) ? InlineBB(x) : InlineBA(x)) + 2; }
inline int InlineBD(const int x) { return ((std::rand() % 2) ? InlineBC(x) : InlineBB(x)) + 2; }
inline int InlineBE(const int x) { return ((std::rand() % 2) ? InlineBD(x) : InlineBC(x)) + 2; }
inline int InlineBF(const int x) { return ((std::rand() % 2) ? InlineBE(x) : InlineBD(x)) + 2; }
inline int InlineBG(const int x) { return ((std::rand() % 2) ? InlineBF(x) : InlineBE(x)) + 2; }
inline int InlineBH(const int x) { return ((std::rand() % 2) ? InlineBG(x) : InlineBF(x)) + 2; }
inline int InlineBI(const int x) { return ((std::rand() % 2) ? InlineBH(x) : InlineBG(x)) + 2; }
inline int InlineBJ(const int x) { return ((std::rand() % 2) ? InlineBI(x) : InlineBH(x)) + 2; }
inline int InlineBK(const int x) { return ((std::rand() % 2) ? InlineBJ(x) : InlineBI(x)) + 2; }
inline int InlineBL(const int x) { return ((std::rand() % 2) ? InlineBK(x) : InlineBJ(x)) + 2; }
inline int InlineBM(const int x) { return ((std::rand() % 2) ? InlineBL(x) : InlineBK(x)) + 2; }
inline int InlineBN(const int x) { return ((std::rand() % 2) ? InlineBM(x) : InlineBL(x)) + 2; }
inline int InlineBO(const int x) { return ((std::rand() % 2) ? InlineBN(x) : InlineBM(x)) + 2; }
inline int InlineBP(const int x) { return ((std::rand() % 2) ? InlineBO(x) : InlineBN(x)) + 2; }
inline int InlineBQ(const int x) { return ((std::rand() % 2) ? InlineBP(x) : InlineBO(x)) + 2; }
inline int InlineBR(const int x) { return ((std::rand() % 2) ? InlineBQ(x) : InlineBP(x)) + 2; }
inline int InlineBS(const int x) { return ((std::rand() % 2) ? InlineBR(x) : InlineBQ(x)) + 2; }
inline int InlineBT(const int x) { return ((std::rand() % 2) ? InlineBS(x) : InlineBR(x)) + 2; }
inline int InlineBU(const int x) { return ((std::rand() % 2) ? InlineBT(x) : InlineBS(x)) + 2; }
inline int InlineBV(const int x) { return ((std::rand() % 2) ? InlineBU(x) : InlineBT(x)) + 2; }
inline int InlineBW(const int x) { return ((std::rand() % 2) ? InlineBV(x) : InlineBU(x)) + 2; }
inline int InlineBX(const int x) { return ((std::rand() % 2) ? InlineBW(x) : InlineBV(x)) + 2; }
inline int InlineBY(const int x) { return ((std::rand() % 2) ? InlineBX(x) : InlineBW(x)) + 2; }
inline int InlineBZ(const int x) { return ((std::rand() % 2) ? InlineBY(x) : InlineBX(x)) + 2; }
inline int InlineCA(const int x) { return ((std::rand() % 2) ? InlineBZ(x) : InlineBY(x)) + 2; }
inline int InlineCB(const int x) { return ((std::rand() % 2) ? InlineCA(x) : InlineBZ(x)) + 2; }
inline int InlineCC(const int x) { return ((std::rand() % 2) ? InlineCB(x) : InlineCA(x)) + 2; }
inline int InlineCD(const int x) { return ((std::rand() % 2) ? InlineCC(x) : InlineCB(x)) + 2; }
inline int InlineCE(const int x) { return ((std::rand() % 2) ? InlineCD(x) : InlineCC(x)) + 2; }
inline int InlineCF(const int x) { return ((std::rand() % 2) ? InlineCE(x) : InlineCD(x)) + 2; }
inline int InlineCG(const int x) { return ((std::rand() % 2) ? InlineCF(x) : InlineCE(x)) + 2; }
inline int InlineCH(const int x) { return ((std::rand() % 2) ? InlineCG(x) : InlineCF(x)) + 2; }
inline int InlineCI(const int x) { return ((std::rand() % 2) ? InlineCH(x) : InlineCG(x)) + 2; }
inline int InlineCJ(const int x) { return ((std::rand() % 2) ? InlineCI(x) : InlineCH(x)) + 2; }
inline int InlineCK(const int x) { return ((std::rand() % 2) ? InlineCJ(x) : InlineCI(x)) + 2; }
inline int InlineCL(const int x) { return ((std::rand() % 2) ? InlineCK(x) : InlineCJ(x)) + 2; }
inline int InlineCM(const int x) { return ((std::rand() % 2) ? InlineCL(x) : InlineCK(x)) + 2; }
inline int InlineCN(const int x) { return ((std::rand() % 2) ? InlineCM(x) : InlineCL(x)) + 2; }
inline int InlineCO(const int x) { return ((std::rand() % 2) ? InlineCN(x) : InlineCM(x)) + 2; }
inline int InlineCP(const int x) { return ((std::rand() % 2) ? InlineCO(x) : InlineCN(x)) + 2; }
inline int InlineCQ(const int x) { return ((std::rand() % 2) ? InlineCP(x) : InlineCO(x)) + 2; }
inline int InlineCR(const int x) { return ((std::rand() % 2) ? InlineCQ(x) : InlineCP(x)) + 2; }
inline int InlineCS(const int x) { return ((std::rand() % 2) ? InlineCR(x) : InlineCQ(x)) + 2; }
inline int InlineCT(const int x) { return ((std::rand() % 2) ? InlineCS(x) : InlineCR(x)) + 2; }
inline int InlineCU(const int x) { return ((std::rand() % 2) ? InlineCT(x) : InlineCS(x)) + 2; }
inline int InlineCV(const int x) { return ((std::rand() % 2) ? InlineCU(x) : InlineCT(x)) + 2; }
inline int InlineCW(const int x) { return ((std::rand() % 2) ? InlineCV(x) : InlineCU(x)) + 2; }
inline int InlineCX(const int x) { return ((std::rand() % 2) ? InlineCW(x) : InlineCV(x)) + 2; }
inline int InlineCY(const int x) { return ((std::rand() % 2) ? InlineCX(x) : InlineCW(x)) + 2; }
inline int InlineCZ(const int x) { return ((std::rand() % 2) ? InlineCY(x) : InlineCX(x)) + 2; }
inline int InlineDA(const int x) { return ((std::rand() % 2) ? InlineCZ(x) : InlineCY(x)) + 2; }
inline int InlineDB(const int x) { return ((std::rand() % 2) ? InlineDA(x) : InlineCZ(x)) + 2; }
inline int InlineDC(const int x) { return ((std::rand() % 2) ? InlineDB(x) : InlineDA(x)) + 2; }
inline int InlineDD(const int x) { return ((std::rand() % 2) ? InlineDC(x) : InlineDB(x)) + 2; }
inline int InlineDE(const int x) { return ((std::rand() % 2) ? InlineDD(x) : InlineDC(x)) + 2; }
inline int InlineDF(const int x) { return ((std::rand() % 2) ? InlineDE(x) : InlineDD(x)) + 2; }
inline int InlineDG(const int x) { return ((std::rand() % 2) ? InlineDF(x) : InlineDE(x)) + 2; }
inline int InlineDH(const int x) { return ((std::rand() % 2) ? InlineDG(x) : InlineDF(x)) + 2; }
inline int InlineDI(const int x) { return ((std::rand() % 2) ? InlineDH(x) : InlineDG(x)) + 2; }
inline int InlineDJ(const int x) { return ((std::rand() % 2) ? InlineDI(x) : InlineDH(x)) + 2; }
inline int InlineDK(const int x) { return ((std::rand() % 2) ? InlineDJ(x) : InlineDI(x)) + 2; }
inline int InlineDL(const int x) { return ((std::rand() % 2) ? InlineDK(x) : InlineDJ(x)) + 2; }
inline int InlineDM(const int x) { return ((std::rand() % 2) ? InlineDL(x) : InlineDK(x)) + 2; }
inline int InlineDN(const int x) { return ((std::rand() % 2) ? InlineDM(x) : InlineDL(x)) + 2; }
inline int InlineDO(const int x) { return ((std::rand() % 2) ? InlineDN(x) : InlineDM(x)) + 2; }
inline int InlineDP(const int x) { return ((std::rand() % 2) ? InlineDO(x) : InlineDN(x)) + 2; }
inline int InlineDQ(const int x) { return ((std::rand() % 2) ? InlineDP(x) : InlineDO(x)) + 2; }
inline int InlineDR(const int x) { return ((std::rand() % 2) ? InlineDQ(x) : InlineDP(x)) + 2; }
inline int InlineDS(const int x) { return ((std::rand() % 2) ? InlineDR(x) : InlineDQ(x)) + 2; }
inline int InlineDT(const int x) { return ((std::rand() % 2) ? InlineDS(x) : InlineDR(x)) + 2; }
inline int InlineDU(const int x) { return ((std::rand() % 2) ? InlineDT(x) : InlineDS(x)) + 2; }
inline int InlineDV(const int x) { return ((std::rand() % 2) ? InlineDU(x) : InlineDT(x)) + 2; }
inline int InlineDW(const int x) { return ((std::rand() % 2) ? InlineDV(x) : InlineDU(x)) + 2; }
inline int InlineDX(const int x) { return ((std::rand() % 2) ? InlineDW(x) : InlineDV(x)) + 2; }
inline int InlineDY(const int x) { return ((std::rand() % 2) ? InlineDX(x) : InlineDW(x)) + 2; }
inline int InlineDZ(const int x) { return ((std::rand() % 2) ? InlineDY(x) : InlineDX(x)) + 2; }
inline int InlineEA(const int x) { return ((std::rand() % 2) ? InlineDZ(x) : InlineDY(x)) + 2; }
inline int InlineEB(const int x) { return ((std::rand() % 2) ? InlineEA(x) : InlineDZ(x)) + 2; }
inline int InlineEC(const int x) { return ((std::rand() % 2) ? InlineEB(x) : InlineEA(x)) + 2; }
inline int InlineED(const int x) { return ((std::rand() % 2) ? InlineEC(x) : InlineEB(x)) + 2; }
inline int InlineEE(const int x) { return ((std::rand() % 2) ? InlineED(x) : InlineEC(x)) + 2; }
inline int InlineEF(const int x) { return ((std::rand() % 2) ? InlineEE(x) : InlineED(x)) + 2; }
inline int InlineEG(const int x) { return ((std::rand() % 2) ? InlineEF(x) : InlineEE(x)) + 2; }
inline int InlineEH(const int x) { return ((std::rand() % 2) ? InlineEG(x) : InlineEF(x)) + 2; }
inline int InlineEI(const int x) { return ((std::rand() % 2) ? InlineEH(x) : InlineEG(x)) + 2; }
inline int InlineEJ(const int x) { return ((std::rand() % 2) ? InlineEI(x) : InlineEH(x)) + 2; }
inline int InlineEK(const int x) { return ((std::rand() % 2) ? InlineEJ(x) : InlineEI(x)) + 2; }
inline int InlineEL(const int x) { return ((std::rand() % 2) ? InlineEK(x) : InlineEJ(x)) + 2; }
inline int InlineEM(const int x) { return ((std::rand() % 2) ? InlineEL(x) : InlineEK(x)) + 2; }
inline int InlineEN(const int x) { return ((std::rand() % 2) ? InlineEM(x) : InlineEL(x)) + 2; }
inline int InlineEO(const int x) { return ((std::rand() % 2) ? InlineEN(x) : InlineEM(x)) + 2; }
inline int InlineEP(const int x) { return ((std::rand() % 2) ? InlineEO(x) : InlineEN(x)) + 2; }
inline int InlineEQ(const int x) { return ((std::rand() % 2) ? InlineEP(x) : InlineEO(x)) + 2; }
inline int InlineER(const int x) { return ((std::rand() % 2) ? InlineEQ(x) : InlineEP(x)) + 2; }
inline int InlineES(const int x) { return ((std::rand() % 2) ? InlineER(x) : InlineEQ(x)) + 2; }
inline int InlineET(const int x) { return ((std::rand() % 2) ? InlineES(x) : InlineER(x)) + 2; }
inline int InlineEU(const int x) { return ((std::rand() % 2) ? InlineET(x) : InlineES(x)) + 2; }
inline int InlineEV(const int x) { return ((std::rand() % 2) ? InlineEU(x) : InlineET(x)) + 2; }
inline int InlineEW(const int x) { return ((std::rand() % 2) ? InlineEV(x) : InlineEU(x)) + 2; }
inline int InlineEX(const int x) { return ((std::rand() % 2) ? InlineEW(x) : InlineEV(x)) + 2; }
inline int InlineEY(const int x) { return ((std::rand() % 2) ? InlineEX(x) : InlineEW(x)) + 2; }
inline int InlineEZ(const int x) { return ((std::rand() % 2) ? InlineEY(x) : InlineEX(x)) + 2; }
inline int InlineFA(const int x) { return ((std::rand() % 2) ? InlineEZ(x) : InlineEY(x)) + 2; }
inline int InlineFB(const int x) { return ((std::rand() % 2) ? InlineFA(x) : InlineEZ(x)) + 2; }
inline int InlineFC(const int x) { return ((std::rand() % 2) ? InlineFB(x) : InlineFA(x)) + 2; }
inline int InlineFD(const int x) { return ((std::rand() % 2) ? InlineFC(x) : InlineFB(x)) + 2; }
inline int InlineFE(const int x) { return ((std::rand() % 2) ? InlineFD(x) : InlineFC(x)) + 2; }
inline int InlineFF(const int x) { return ((std::rand() % 2) ? InlineFE(x) : InlineFD(x)) + 2; }
inline int InlineFG(const int x) { return ((std::rand() % 2) ? InlineFF(x) : InlineFE(x)) + 2; }
inline int InlineFH(const int x) { return ((std::rand() % 2) ? InlineFG(x) : InlineFF(x)) + 2; }
inline int InlineFI(const int x) { return ((std::rand() % 2) ? InlineFH(x) : InlineFG(x)) + 2; }
inline int InlineFJ(const int x) { return ((std::rand() % 2) ? InlineFI(x) : InlineFH(x)) + 2; }
inline int InlineFK(const int x) { return ((std::rand() % 2) ? InlineFJ(x) : InlineFI(x)) + 2; }
inline int InlineFL(const int x) { return ((std::rand() % 2) ? InlineFK(x) : InlineFJ(x)) + 2; }
inline int InlineFM(const int x) { return ((std::rand() % 2) ? InlineFL(x) : InlineFK(x)) + 2; }
inline int InlineFN(const int x) { return ((std::rand() % 2) ? InlineFM(x) : InlineFL(x)) + 2; }
inline int InlineFO(const int x) { return ((std::rand() % 2) ? InlineFN(x) : InlineFM(x)) + 2; }
inline int InlineFP(const int x) { return ((std::rand() % 2) ? InlineFO(x) : InlineFN(x)) + 2; }
inline int InlineFQ(const int x) { return ((std::rand() % 2) ? InlineFP(x) : InlineFO(x)) + 2; }
inline int InlineFR(const int x) { return ((std::rand() % 2) ? InlineFQ(x) : InlineFP(x)) + 2; }
inline int InlineFS(const int x) { return ((std::rand() % 2) ? InlineFR(x) : InlineFQ(x)) + 2; }
inline int InlineFT(const int x) { return ((std::rand() % 2) ? InlineFS(x) : InlineFR(x)) + 2; }
inline int InlineFU(const int x) { return ((std::rand() % 2) ? InlineFT(x) : InlineFS(x)) + 2; }
inline int InlineFV(const int x) { return ((std::rand() % 2) ? InlineFU(x) : InlineFT(x)) + 2; }
inline int InlineFW(const int x) { return ((std::rand() % 2) ? InlineFV(x) : InlineFU(x)) + 2; }
inline int InlineFX(const int x) { return ((std::rand() % 2) ? InlineFW(x) : InlineFV(x)) + 2; }
inline int InlineFY(const int x) { return ((std::rand() % 2) ? InlineFX(x) : InlineFW(x)) + 2; }
inline int InlineFZ(const int x) { return ((std::rand() % 2) ? InlineFY(x) : InlineFX(x)) + 2; }
inline int InlineGA(const int x) { return ((std::rand() % 2) ? InlineFZ(x) : InlineFY(x)) + 2; }
inline int InlineGB(const int x) { return ((std::rand() % 2) ? InlineGA(x) : InlineFZ(x)) + 2; }
inline int InlineGC(const int x) { return ((std::rand() % 2) ? InlineGB(x) : InlineGA(x)) + 2; }
inline int InlineGD(const int x) { return ((std::rand() % 2) ? InlineGC(x) : InlineGB(x)) + 2; }
inline int InlineGE(const int x) { return ((std::rand() % 2) ? InlineGD(x) : InlineGC(x)) + 2; }
inline int InlineGF(const int x) { return ((std::rand() % 2) ? InlineGE(x) : InlineGD(x)) + 2; }
inline int InlineGG(const int x) { return ((std::rand() % 2) ? InlineGF(x) : InlineGE(x)) + 2; }
inline int InlineGH(const int x) { return ((std::rand() % 2) ? InlineGG(x) : InlineGF(x)) + 2; }
inline int InlineGI(const int x) { return ((std::rand() % 2) ? InlineGH(x) : InlineGG(x)) + 2; }
inline int InlineGJ(const int x) { return ((std::rand() % 2) ? InlineGI(x) : InlineGH(x)) + 2; }
inline int InlineGK(const int x) { return ((std::rand() % 2) ? InlineGJ(x) : InlineGI(x)) + 2; }
inline int InlineGL(const int x) { return ((std::rand() % 2) ? InlineGK(x) : InlineGJ(x)) + 2; }
inline int InlineGM(const int x) { return ((std::rand() % 2) ? InlineGL(x) : InlineGK(x)) + 2; }
inline int InlineGN(const int x) { return ((std::rand() % 2) ? InlineGM(x) : InlineGL(x)) + 2; }
inline int InlineGO(const int x) { return ((std::rand() % 2) ? InlineGN(x) : InlineGM(x)) + 2; }
inline int InlineGP(const int x) { return ((std::rand() % 2) ? InlineGO(x) : InlineGN(x)) + 2; }
inline int InlineGQ(const int x) { return ((std::rand() % 2) ? InlineGP(x) : InlineGO(x)) + 2; }
inline int InlineGR(const int x) { return ((std::rand() % 2) ? InlineGQ(x) : InlineGP(x)) + 2; }
inline int InlineGS(const int x) { return ((std::rand() % 2) ? InlineGR(x) : InlineGQ(x)) + 2; }
inline int InlineGT(const int x) { return ((std::rand() % 2) ? InlineGS(x) : InlineGR(x)) + 2; }
inline int InlineGU(const int x) { return ((std::rand() % 2) ? InlineGT(x) : InlineGS(x)) + 2; }
inline int InlineGV(const int x) { return ((std::rand() % 2) ? InlineGU(x) : InlineGT(x)) + 2; }
inline int InlineGW(const int x) { return ((std::rand() % 2) ? InlineGV(x) : InlineGU(x)) + 2; }
inline int InlineGX(const int x) { return ((std::rand() % 2) ? InlineGW(x) : InlineGV(x)) + 2; }
inline int InlineGY(const int x) { return ((std::rand() % 2) ? InlineGX(x) : InlineGW(x)) + 2; }
inline int InlineGZ(const int x) { return ((std::rand() % 2) ? InlineGY(x) : InlineGX(x)) + 2; }
inline int InlineHA(const int x) { return ((std::rand() % 2) ? InlineGZ(x) : InlineGY(x)) + 2; }
inline int InlineHB(const int x) { return ((std::rand() % 2) ? InlineHA(x) : InlineGZ(x)) + 2; }
inline int InlineHC(const int x) { return ((std::rand() % 2) ? InlineHB(x) : InlineHA(x)) + 2; }
inline int InlineHD(const int x) { return ((std::rand() % 2) ? InlineHC(x) : InlineHB(x)) + 2; }
inline int InlineHE(const int x) { return ((std::rand() % 2) ? InlineHD(x) : InlineHC(x)) + 2; }
inline int InlineHF(const int x) { return ((std::rand() % 2) ? InlineHE(x) : InlineHD(x)) + 2; }
inline int InlineHG(const int x) { return ((std::rand() % 2) ? InlineHF(x) : InlineHE(x)) + 2; }
inline int InlineHH(const int x) { return ((std::rand() % 2) ? InlineHG(x) : InlineHF(x)) + 2; }
inline int InlineHI(const int x) { return ((std::rand() % 2) ? InlineHH(x) : InlineHG(x)) + 2; }
inline int InlineHJ(const int x) { return ((std::rand() % 2) ? InlineHI(x) : InlineHH(x)) + 2; }
inline int InlineHK(const int x) { return ((std::rand() % 2) ? InlineHJ(x) : InlineHI(x)) + 2; }
inline int InlineHL(const int x) { return ((std::rand() % 2) ? InlineHK(x) : InlineHJ(x)) + 2; }
inline int InlineHM(const int x) { return ((std::rand() % 2) ? InlineHL(x) : InlineHK(x)) + 2; }
inline int InlineHN(const int x) { return ((std::rand() % 2) ? InlineHM(x) : InlineHL(x)) + 2; }
inline int InlineHO(const int x) { return ((std::rand() % 2) ? InlineHN(x) : InlineHM(x)) + 2; }
inline int InlineHP(const int x) { return ((std::rand() % 2) ? InlineHO(x) : InlineHN(x)) + 2; }
inline int InlineHQ(const int x) { return ((std::rand() % 2) ? InlineHP(x) : InlineHO(x)) + 2; }
inline int InlineHR(const int x) { return ((std::rand() % 2) ? InlineHQ(x) : InlineHP(x)) + 2; }
inline int InlineHS(const int x) { return ((std::rand() % 2) ? InlineHR(x) : InlineHQ(x)) + 2; }
inline int InlineHT(const int x) { return ((std::rand() % 2) ? InlineHS(x) : InlineHR(x)) + 2; }
inline int InlineHU(const int x) { return ((std::rand() % 2) ? InlineHT(x) : InlineHS(x)) + 2; }
inline int InlineHV(const int x) { return ((std::rand() % 2) ? InlineHU(x) : InlineHT(x)) + 2; }
inline int InlineHW(const int x) { return ((std::rand() % 2) ? InlineHV(x) : InlineHU(x)) + 2; }
inline int InlineHX(const int x) { return ((std::rand() % 2) ? InlineHW(x) : InlineHV(x)) + 2; }
inline int InlineHY(const int x) { return ((std::rand() % 2) ? InlineHX(x) : InlineHW(x)) + 2; }
inline int InlineHZ(const int x) { return ((std::rand() % 2) ? InlineHY(x) : InlineHX(x)) + 2; }
inline int InlineIA(const int x) { return ((std::rand() % 2) ? InlineHZ(x) : InlineHY(x)) + 2; }
inline int InlineIB(const int x) { return ((std::rand() % 2) ? InlineIA(x) : InlineHZ(x)) + 2; }
inline int InlineIC(const int x) { return ((std::rand() % 2) ? InlineIB(x) : InlineIA(x)) + 2; }
inline int InlineID(const int x) { return ((std::rand() % 2) ? InlineIC(x) : InlineIB(x)) + 2; }
inline int InlineIE(const int x) { return ((std::rand() % 2) ? InlineID(x) : InlineIC(x)) + 2; }
inline int InlineIF(const int x) { return ((std::rand() % 2) ? InlineIE(x) : InlineID(x)) + 2; }
inline int InlineIG(const int x) { return ((std::rand() % 2) ? InlineIF(x) : InlineIE(x)) + 2; }
inline int InlineIH(const int x) { return ((std::rand() % 2) ? InlineIG(x) : InlineIF(x)) + 2; }
inline int InlineII(const int x) { return ((std::rand() % 2) ? InlineIH(x) : InlineIG(x)) + 2; }
inline int InlineIJ(const int x) { return ((std::rand() % 2) ? InlineII(x) : InlineIH(x)) + 2; }
inline int InlineIK(const int x) { return ((std::rand() % 2) ? InlineIJ(x) : InlineII(x)) + 2; }
inline int InlineIL(const int x) { return ((std::rand() % 2) ? InlineIK(x) : InlineIJ(x)) + 2; }
inline int InlineIM(const int x) { return ((std::rand() % 2) ? InlineIL(x) : InlineIK(x)) + 2; }
inline int InlineIN(const int x) { return ((std::rand() % 2) ? InlineIM(x) : InlineIL(x)) + 2; }
inline int InlineIO(const int x) { return ((std::rand() % 2) ? InlineIN(x) : InlineIM(x)) + 2; }
inline int InlineIP(const int x) { return ((std::rand() % 2) ? InlineIO(x) : InlineIN(x)) + 2; }
inline int InlineIQ(const int x) { return ((std::rand() % 2) ? InlineIP(x) : InlineIO(x)) + 2; }
inline int InlineIR(const int x) { return ((std::rand() % 2) ? InlineIQ(x) : InlineIP(x)) + 2; }
inline int InlineIS(const int x) { return ((std::rand() % 2) ? InlineIR(x) : InlineIQ(x)) + 2; }
inline int InlineIT(const int x) { return ((std::rand() % 2) ? InlineIS(x) : InlineIR(x)) + 2; }
inline int InlineIU(const int x) { return ((std::rand() % 2) ? InlineIT(x) : InlineIS(x)) + 2; }
inline int InlineIV(const int x) { return ((std::rand() % 2) ? InlineIU(x) : InlineIT(x)) + 2; }
inline int InlineIW(const int x) { return ((std::rand() % 2) ? InlineIV(x) : InlineIU(x)) + 2; }
inline int InlineIX(const int x) { return ((std::rand() % 2) ? InlineIW(x) : InlineIV(x)) + 2; }
inline int InlineIY(const int x) { return ((std::rand() % 2) ? InlineIX(x) : InlineIW(x)) + 2; }
inline int InlineIZ(const int x) { return ((std::rand() % 2) ? InlineIY(x) : InlineIX(x)) + 2; }
inline int InlineJA(const int x) { return ((std::rand() % 2) ? InlineIZ(x) : InlineIY(x)) + 2; }
inline int InlineJB(const int x) { return ((std::rand() % 2) ? InlineJA(x) : InlineIZ(x)) + 2; }
inline int InlineJC(const int x) { return ((std::rand() % 2) ? InlineJB(x) : InlineJA(x)) + 2; }
inline int InlineJD(const int x) { return ((std::rand() % 2) ? InlineJC(x) : InlineJB(x)) + 2; }
inline int InlineJE(const int x) { return ((std::rand() % 2) ? InlineJD(x) : InlineJC(x)) + 2; }
inline int InlineJF(const int x) { return ((std::rand() % 2) ? InlineJE(x) : InlineJD(x)) + 2; }
inline int InlineJG(const int x) { return ((std::rand() % 2) ? InlineJF(x) : InlineJE(x)) + 2; }
inline int InlineJH(const int x) { return ((std::rand() % 2) ? InlineJG(x) : InlineJF(x)) + 2; }
inline int InlineJI(const int x) { return ((std::rand() % 2) ? InlineJH(x) : InlineJG(x)) + 2; }
inline int InlineJJ(const int x) { return ((std::rand() % 2) ? InlineJI(x) : InlineJH(x)) + 2; }
inline int InlineJK(const int x) { return ((std::rand() % 2) ? InlineJJ(x) : InlineJI(x)) + 2; }
inline int InlineJL(const int x) { return ((std::rand() % 2) ? InlineJK(x) : InlineJJ(x)) + 2; }
inline int InlineJM(const int x) { return ((std::rand() % 2) ? InlineJL(x) : InlineJK(x)) + 2; }
inline int InlineJN(const int x) { return ((std::rand() % 2) ? InlineJM(x) : InlineJL(x)) + 2; }
inline int InlineJO(const int x) { return ((std::rand() % 2) ? InlineJN(x) : InlineJM(x)) + 2; }
inline int InlineJP(const int x) { return ((std::rand() % 2) ? InlineJO(x) : InlineJN(x)) + 2; }
inline int InlineJQ(const int x) { return ((std::rand() % 2) ? InlineJP(x) : InlineJO(x)) + 2; }
inline int InlineJR(const int x) { return ((std::rand() % 2) ? InlineJQ(x) : InlineJP(x)) + 2; }
inline int InlineJS(const int x) { return ((std::rand() % 2) ? InlineJR(x) : InlineJQ(x)) + 2; }
inline int InlineJT(const int x) { return ((std::rand() % 2) ? InlineJS(x) : InlineJR(x)) + 2; }
inline int InlineJU(const int x) { return ((std::rand() % 2) ? InlineJT(x) : InlineJS(x)) + 2; }
inline int InlineJV(const int x) { return ((std::rand() % 2) ? InlineJU(x) : InlineJT(x)) + 2; }
inline int InlineJW(const int x) { return ((std::rand() % 2) ? InlineJV(x) : InlineJU(x)) + 2; }
inline int InlineJX(const int x) { return ((std::rand() % 2) ? InlineJW(x) : InlineJV(x)) + 2; }
inline int InlineJY(const int x) { return ((std::rand() % 2) ? InlineJX(x) : InlineJW(x)) + 2; }
inline int InlineJZ(const int x) { return ((std::rand() % 2) ? InlineJY(x) : InlineJX(x)) + 2; }
inline int InlineKA(const int x) { return ((std::rand() % 2) ? InlineJZ(x) : InlineJY(x)) + 2; }
inline int InlineKB(const int x) { return ((std::rand() % 2) ? InlineKA(x) : InlineJZ(x)) + 2; }
inline int InlineKC(const int x) { return ((std::rand() % 2) ? InlineKB(x) : InlineKA(x)) + 2; }
inline int InlineKD(const int x) { return ((std::rand() % 2) ? InlineKC(x) : InlineKB(x)) + 2; }
inline int InlineKE(const int x) { return ((std::rand() % 2) ? InlineKD(x) : InlineKC(x)) + 2; }
inline int InlineKF(const int x) { return ((std::rand() % 2) ? InlineKE(x) : InlineKD(x)) + 2; }
inline int InlineKG(const int x) { return ((std::rand() % 2) ? InlineKF(x) : InlineKE(x)) + 2; }
inline int InlineKH(const int x) { return ((std::rand() % 2) ? InlineKG(x) : InlineKF(x)) + 2; }
inline int InlineKI(const int x) { return ((std::rand() % 2) ? InlineKH(x) : InlineKG(x)) + 2; }
inline int InlineKJ(const int x) { return ((std::rand() % 2) ? InlineKI(x) : InlineKH(x)) + 2; }
inline int InlineKK(const int x) { return ((std::rand() % 2) ? InlineKJ(x) : InlineKI(x)) + 2; }
inline int InlineKL(const int x) { return ((std::rand() % 2) ? InlineKK(x) : InlineKJ(x)) + 2; }
inline int InlineKM(const int x) { return ((std::rand() % 2) ? InlineKL(x) : InlineKK(x)) + 2; }
inline int InlineKN(const int x) { return ((std::rand() % 2) ? InlineKM(x) : InlineKL(x)) + 2; }
inline int InlineKO(const int x) { return ((std::rand() % 2) ? InlineKN(x) : InlineKM(x)) + 2; }
inline int InlineKP(const int x) { return ((std::rand() % 2) ? InlineKO(x) : InlineKN(x)) + 2; }
inline int InlineKQ(const int x) { return ((std::rand() % 2) ? InlineKP(x) : InlineKO(x)) + 2; }
inline int InlineKR(const int x) { return ((std::rand() % 2) ? InlineKQ(x) : InlineKP(x)) + 2; }
inline int InlineKS(const int x) { return ((std::rand() % 2) ? InlineKR(x) : InlineKQ(x)) + 2; }
inline int InlineKT(const int x) { return ((std::rand() % 2) ? InlineKS(x) : InlineKR(x)) + 2; }
inline int InlineKU(const int x) { return ((std::rand() % 2) ? InlineKT(x) : InlineKS(x)) + 2; }
inline int InlineKV(const int x) { return ((std::rand() % 2) ? InlineKU(x) : InlineKT(x)) + 2; }
inline int InlineKW(const int x) { return ((std::rand() % 2) ? InlineKV(x) : InlineKU(x)) + 2; }
inline int InlineKX(const int x) { return ((std::rand() % 2) ? InlineKW(x) : InlineKV(x)) + 2; }
inline int InlineKY(const int x) { return ((std::rand() % 2) ? InlineKX(x) : InlineKW(x)) + 2; }
inline int InlineKZ(const int x) { return ((std::rand() % 2) ? InlineKY(x) : InlineKX(x)) + 2; }
inline int InlineLA(const int x) { return ((std::rand() % 2) ? InlineKZ(x) : InlineKY(x)) + 2; }
inline int InlineLB(const int x) { return ((std::rand() % 2) ? InlineLA(x) : InlineKZ(x)) + 2; }
inline int InlineLC(const int x) { return ((std::rand() % 2) ? InlineLB(x) : InlineLA(x)) + 2; }
inline int InlineLD(const int x) { return ((std::rand() % 2) ? InlineLC(x) : InlineLB(x)) + 2; }
inline int InlineLE(const int x) { return ((std::rand() % 2) ? InlineLD(x) : InlineLC(x)) + 2; }
inline int InlineLF(const int x) { return ((std::rand() % 2) ? InlineLE(x) : InlineLD(x)) + 2; }
inline int InlineLG(const int x) { return ((std::rand() % 2) ? InlineLF(x) : InlineLE(x)) + 2; }
inline int InlineLH(const int x) { return ((std::rand() % 2) ? InlineLG(x) : InlineLF(x)) + 2; }
inline int InlineLI(const int x) { return ((std::rand() % 2) ? InlineLH(x) : InlineLG(x)) + 2; }
inline int InlineLJ(const int x) { return ((std::rand() % 2) ? InlineLI(x) : InlineLH(x)) + 2; }
inline int InlineLK(const int x) { return ((std::rand() % 2) ? InlineLJ(x) : InlineLI(x)) + 2; }
inline int InlineLL(const int x) { return ((std::rand() % 2) ? InlineLK(x) : InlineLJ(x)) + 2; }
inline int InlineLM(const int x) { return ((std::rand() % 2) ? InlineLL(x) : InlineLK(x)) + 2; }
inline int InlineLN(const int x) { return ((std::rand() % 2) ? InlineLM(x) : InlineLL(x)) + 2; }
inline int InlineLO(const int x) { return ((std::rand() % 2) ? InlineLN(x) : InlineLM(x)) + 2; }
inline int InlineLP(const int x) { return ((std::rand() % 2) ? InlineLO(x) : InlineLN(x)) + 2; }
inline int InlineLQ(const int x) { return ((std::rand() % 2) ? InlineLP(x) : InlineLO(x)) + 2; }
inline int InlineLR(const int x) { return ((std::rand() % 2) ? InlineLQ(x) : InlineLP(x)) + 2; }
inline int InlineLS(const int x) { return ((std::rand() % 2) ? InlineLR(x) : InlineLQ(x)) + 2; }
inline int InlineLT(const int x) { return ((std::rand() % 2) ? InlineLS(x) : InlineLR(x)) + 2; }
inline int InlineLU(const int x) { return ((std::rand() % 2) ? InlineLT(x) : InlineLS(x)) + 2; }
inline int InlineLV(const int x) { return ((std::rand() % 2) ? InlineLU(x) : InlineLT(x)) + 2; }
inline int InlineLW(const int x) { return ((std::rand() % 2) ? InlineLV(x) : InlineLU(x)) + 2; }
inline int InlineLX(const int x) { return ((std::rand() % 2) ? InlineLW(x) : InlineLV(x)) + 2; }
inline int InlineLY(const int x) { return ((std::rand() % 2) ? InlineLX(x) : InlineLW(x)) + 2; }
inline int InlineLZ(const int x) { return ((std::rand() % 2) ? InlineLY(x) : InlineLX(x)) + 2; }
inline int InlineMA(const int x) { return ((std::rand() % 2) ? InlineLZ(x) : InlineLY(x)) + 2; }
inline int InlineMB(const int x) { return ((std::rand() % 2) ? InlineMA(x) : InlineLZ(x)) + 2; }
inline int InlineMC(const int x) { return ((std::rand() % 2) ? InlineMB(x) : InlineMA(x)) + 2; }
inline int InlineMD(const int x) { return ((std::rand() % 2) ? InlineMC(x) : InlineMB(x)) + 2; }
inline int InlineME(const int x) { return ((std::rand() % 2) ? InlineMD(x) : InlineMC(x)) + 2; }
inline int InlineMF(const int x) { return ((std::rand() % 2) ? InlineME(x) : InlineMD(x)) + 2; }
inline int InlineMG(const int x) { return ((std::rand() % 2) ? InlineMF(x) : InlineME(x)) + 2; }
inline int InlineMH(const int x) { return ((std::rand() % 2) ? InlineMG(x) : InlineMF(x)) + 2; }
inline int InlineMI(const int x) { return ((std::rand() % 2) ? InlineMH(x) : InlineMG(x)) + 2; }
inline int InlineMJ(const int x) { return ((std::rand() % 2) ? InlineMI(x) : InlineMH(x)) + 2; }
inline int InlineMK(const int x) { return ((std::rand() % 2) ? InlineMJ(x) : InlineMI(x)) + 2; }
inline int InlineML(const int x) { return ((std::rand() % 2) ? InlineMK(x) : InlineMJ(x)) + 2; }
inline int InlineMM(const int x) { return ((std::rand() % 2) ? InlineML(x) : InlineMK(x)) + 2; }
inline int InlineMN(const int x) { return ((std::rand() % 2) ? InlineMM(x) : InlineML(x)) + 2; }
inline int InlineMO(const int x) { return ((std::rand() % 2) ? InlineMN(x) : InlineMM(x)) + 2; }
inline int InlineMP(const int x) { return ((std::rand() % 2) ? InlineMO(x) : InlineMN(x)) + 2; }
inline int InlineMQ(const int x) { return ((std::rand() % 2) ? InlineMP(x) : InlineMO(x)) + 2; }
inline int InlineMR(const int x) { return ((std::rand() % 2) ? InlineMQ(x) : InlineMP(x)) + 2; }
inline int InlineMS(const int x) { return ((std::rand() % 2) ? InlineMR(x) : InlineMQ(x)) + 2; }
inline int InlineMT(const int x) { return ((std::rand() % 2) ? InlineMS(x) : InlineMR(x)) + 2; }
inline int InlineMU(const int x) { return ((std::rand() % 2) ? InlineMT(x) : InlineMS(x)) + 2; }
inline int InlineMV(const int x) { return ((std::rand() % 2) ? InlineMU(x) : InlineMT(x)) + 2; }
inline int InlineMW(const int x) { return ((std::rand() % 2) ? InlineMV(x) : InlineMU(x)) + 2; }
inline int InlineMX(const int x) { return ((std::rand() % 2) ? InlineMW(x) : InlineMV(x)) + 2; }
inline int InlineMY(const int x) { return ((std::rand() % 2) ? InlineMX(x) : InlineMW(x)) + 2; }
inline int InlineMZ(const int x) { return ((std::rand() % 2) ? InlineMY(x) : InlineMX(x)) + 2; }
inline int InlineNA(const int x) { return ((std::rand() % 2) ? InlineMZ(x) : InlineMY(x)) + 2; }
inline int InlineNB(const int x) { return ((std::rand() % 2) ? InlineNA(x) : InlineMZ(x)) + 2; }
inline int InlineNC(const int x) { return ((std::rand() % 2) ? InlineNB(x) : InlineNA(x)) + 2; }
inline int InlineND(const int x) { return ((std::rand() % 2) ? InlineNC(x) : InlineNB(x)) + 2; }
inline int InlineNE(const int x) { return ((std::rand() % 2) ? InlineND(x) : InlineNC(x)) + 2; }
inline int InlineNF(const int x) { return ((std::rand() % 2) ? InlineNE(x) : InlineND(x)) + 2; }
inline int InlineNG(const int x) { return ((std::rand() % 2) ? InlineNF(x) : InlineNE(x)) + 2; }
inline int InlineNH(const int x) { return ((std::rand() % 2) ? InlineNG(x) : InlineNF(x)) + 2; }
inline int InlineNI(const int x) { return ((std::rand() % 2) ? InlineNH(x) : InlineNG(x)) + 2; }
inline int InlineNJ(const int x) { return ((std::rand() % 2) ? InlineNI(x) : InlineNH(x)) + 2; }
inline int InlineNK(const int x) { return ((std::rand() % 2) ? InlineNJ(x) : InlineNI(x)) + 2; }
inline int InlineNL(const int x) { return ((std::rand() % 2) ? InlineNK(x) : InlineNJ(x)) + 2; }
inline int InlineNM(const int x) { return ((std::rand() % 2) ? InlineNL(x) : InlineNK(x)) + 2; }
inline int InlineNN(const int x) { return ((std::rand() % 2) ? InlineNM(x) : InlineNL(x)) + 2; }
inline int InlineNO(const int x) { return ((std::rand() % 2) ? InlineNN(x) : InlineNM(x)) + 2; }
inline int InlineNP(const int x) { return ((std::rand() % 2) ? InlineNO(x) : InlineNN(x)) + 2; }
inline int InlineNQ(const int x) { return ((std::rand() % 2) ? InlineNP(x) : InlineNO(x)) + 2; }
inline int InlineNR(const int x) { return ((std::rand() % 2) ? InlineNQ(x) : InlineNP(x)) + 2; }
inline int InlineNS(const int x) { return ((std::rand() % 2) ? InlineNR(x) : InlineNQ(x)) + 2; }
inline int InlineNT(const int x) { return ((std::rand() % 2) ? InlineNS(x) : InlineNR(x)) + 2; }
inline int InlineNU(const int x) { return ((std::rand() % 2) ? InlineNT(x) : InlineNS(x)) + 2; }
inline int InlineNV(const int x) { return ((std::rand() % 2) ? InlineNU(x) : InlineNT(x)) + 2; }
inline int InlineNW(const int x) { return ((std::rand() % 2) ? InlineNV(x) : InlineNU(x)) + 2; }
inline int InlineNX(const int x) { return ((std::rand() % 2) ? InlineNW(x) : InlineNV(x)) + 2; }
inline int InlineNY(const int x) { return ((std::rand() % 2) ? InlineNX(x) : InlineNW(x)) + 2; }
inline int InlineNZ(const int x) { return ((std::rand() % 2) ? InlineNY(x) : InlineNX(x)) + 2; }
inline int InlineOA(const int x) { return ((std::rand() % 2) ? InlineNZ(x) : InlineNY(x)) + 2; }
inline int InlineOB(const int x) { return ((std::rand() % 2) ? InlineOA(x) : InlineNZ(x)) + 2; }
inline int InlineOC(const int x) { return ((std::rand() % 2) ? InlineOB(x) : InlineOA(x)) + 2; }
inline int InlineOD(const int x) { return ((std::rand() % 2) ? InlineOC(x) : InlineOB(x)) + 2; }
inline int InlineOE(const int x) { return ((std::rand() % 2) ? InlineOD(x) : InlineOC(x)) + 2; }
inline int InlineOF(const int x) { return ((std::rand() % 2) ? InlineOE(x) : InlineOD(x)) + 2; }
inline int InlineOG(const int x) { return ((std::rand() % 2) ? InlineOF(x) : InlineOE(x)) + 2; }
inline int InlineOH(const int x) { return ((std::rand() % 2) ? InlineOG(x) : InlineOF(x)) + 2; }
inline int InlineOI(const int x) { return ((std::rand() % 2) ? InlineOH(x) : InlineOG(x)) + 2; }
inline int InlineOJ(const int x) { return ((std::rand() % 2) ? InlineOI(x) : InlineOH(x)) + 2; }
inline int InlineOK(const int x) { return ((std::rand() % 2) ? InlineOJ(x) : InlineOI(x)) + 2; }
inline int InlineOL(const int x) { return ((std::rand() % 2) ? InlineOK(x) : InlineOJ(x)) + 2; }
inline int InlineOM(const int x) { return ((std::rand() % 2) ? InlineOL(x) : InlineOK(x)) + 2; }
inline int InlineON(const int x) { return ((std::rand() % 2) ? InlineOM(x) : InlineOL(x)) + 2; }
inline int InlineOO(const int x) { return ((std::rand() % 2) ? InlineON(x) : InlineOM(x)) + 2; }
inline int InlineOP(const int x) { return ((std::rand() % 2) ? InlineOO(x) : InlineON(x)) + 2; }
inline int InlineOQ(const int x) { return ((std::rand() % 2) ? InlineOP(x) : InlineOO(x)) + 2; }
inline int InlineOR(const int x) { return ((std::rand() % 2) ? InlineOQ(x) : InlineOP(x)) + 2; }
inline int InlineOS(const int x) { return ((std::rand() % 2) ? InlineOR(x) : InlineOQ(x)) + 2; }
inline int InlineOT(const int x) { return ((std::rand() % 2) ? InlineOS(x) : InlineOR(x)) + 2; }
inline int InlineOU(const int x) { return ((std::rand() % 2) ? InlineOT(x) : InlineOS(x)) + 2; }
inline int InlineOV(const int x) { return ((std::rand() % 2) ? InlineOU(x) : InlineOT(x)) + 2; }
inline int InlineOW(const int x) { return ((std::rand() % 2) ? InlineOV(x) : InlineOU(x)) + 2; }
inline int InlineOX(const int x) { return ((std::rand() % 2) ? InlineOW(x) : InlineOV(x)) + 2; }
inline int InlineOY(const int x) { return ((std::rand() % 2) ? InlineOX(x) : InlineOW(x)) + 2; }
inline int InlineOZ(const int x) { return ((std::rand() % 2) ? InlineOY(x) : InlineOX(x)) + 2; }
inline int InlinePA(const int x) { return ((std::rand() % 2) ? InlineOZ(x) : InlineOY(x)) + 2; }
inline int InlinePB(const int x) { return ((std::rand() % 2) ? InlinePA(x) : InlineOZ(x)) + 2; }
inline int InlinePC(const int x) { return ((std::rand() % 2) ? InlinePB(x) : InlinePA(x)) + 2; }
inline int InlinePD(const int x) { return ((std::rand() % 2) ? InlinePC(x) : InlinePB(x)) + 2; }
inline int InlinePE(const int x) { return ((std::rand() % 2) ? InlinePD(x) : InlinePC(x)) + 2; }
inline int InlinePF(const int x) { return ((std::rand() % 2) ? InlinePE(x) : InlinePD(x)) + 2; }
inline int InlinePG(const int x) { return ((std::rand() % 2) ? InlinePF(x) : InlinePE(x)) + 2; }
inline int InlinePH(const int x) { return ((std::rand() % 2) ? InlinePG(x) : InlinePF(x)) + 2; }
inline int InlinePI(const int x) { return ((std::rand() % 2) ? InlinePH(x) : InlinePG(x)) + 2; }
inline int InlinePJ(const int x) { return ((std::rand() % 2) ? InlinePI(x) : InlinePH(x)) + 2; }
inline int InlinePK(const int x) { return ((std::rand() % 2) ? InlinePJ(x) : InlinePI(x)) + 2; }
inline int InlinePL(const int x) { return ((std::rand() % 2) ? InlinePK(x) : InlinePJ(x)) + 2; }
inline int InlinePM(const int x) { return ((std::rand() % 2) ? InlinePL(x) : InlinePK(x)) + 2; }
inline int InlinePN(const int x) { return ((std::rand() % 2) ? InlinePM(x) : InlinePL(x)) + 2; }
inline int InlinePO(const int x) { return ((std::rand() % 2) ? InlinePN(x) : InlinePM(x)) + 2; }
inline int InlinePP(const int x) { return ((std::rand() % 2) ? InlinePO(x) : InlinePN(x)) + 2; }
inline int InlinePQ(const int x) { return ((std::rand() % 2) ? InlinePP(x) : InlinePO(x)) + 2; }
inline int InlinePR(const int x) { return ((std::rand() % 2) ? InlinePQ(x) : InlinePP(x)) + 2; }
inline int InlinePS(const int x) { return ((std::rand() % 2) ? InlinePR(x) : InlinePQ(x)) + 2; }
inline int InlinePT(const int x) { return ((std::rand() % 2) ? InlinePS(x) : InlinePR(x)) + 2; }
inline int InlinePU(const int x) { return ((std::rand() % 2) ? InlinePT(x) : InlinePS(x)) + 2; }
inline int InlinePV(const int x) { return ((std::rand() % 2) ? InlinePU(x) : InlinePT(x)) + 2; }
inline int InlinePW(const int x) { return ((std::rand() % 2) ? InlinePV(x) : InlinePU(x)) + 2; }
inline int InlinePX(const int x) { return ((std::rand() % 2) ? InlinePW(x) : InlinePV(x)) + 2; }
inline int InlinePY(const int x) { return ((std::rand() % 2) ? InlinePX(x) : InlinePW(x)) + 2; }
inline int InlinePZ(const int x) { return ((std::rand() % 2) ? InlinePY(x) : InlinePX(x)) + 2; }
inline int InlineQA(const int x) { return ((std::rand() % 2) ? InlinePZ(x) : InlinePY(x)) + 2; }
inline int InlineQB(const int x) { return ((std::rand() % 2) ? InlineQA(x) : InlinePZ(x)) + 2; }
inline int InlineQC(const int x) { return ((std::rand() % 2) ? InlineQB(x) : InlineQA(x)) + 2; }
inline int InlineQD(const int x) { return ((std::rand() % 2) ? InlineQC(x) : InlineQB(x)) + 2; }
inline int InlineQE(const int x) { return ((std::rand() % 2) ? InlineQD(x) : InlineQC(x)) + 2; }
inline int InlineQF(const int x) { return ((std::rand() % 2) ? InlineQE(x) : InlineQD(x)) + 2; }
inline int InlineQG(const int x) { return ((std::rand() % 2) ? InlineQF(x) : InlineQE(x)) + 2; }
inline int InlineQH(const int x) { return ((std::rand() % 2) ? InlineQG(x) : InlineQF(x)) + 2; }
inline int InlineQI(const int x) { return ((std::rand() % 2) ? InlineQH(x) : InlineQG(x)) + 2; }
inline int InlineQJ(const int x) { return ((std::rand() % 2) ? InlineQI(x) : InlineQH(x)) + 2; }
inline int InlineQK(const int x) { return ((std::rand() % 2) ? InlineQJ(x) : InlineQI(x)) + 2; }
inline int InlineQL(const int x) { return ((std::rand() % 2) ? InlineQK(x) : InlineQJ(x)) + 2; }
inline int InlineQM(const int x) { return ((std::rand() % 2) ? InlineQL(x) : InlineQK(x)) + 2; }
inline int InlineQN(const int x) { return ((std::rand() % 2) ? InlineQM(x) : InlineQL(x)) + 2; }
inline int InlineQO(const int x) { return ((std::rand() % 2) ? InlineQN(x) : InlineQM(x)) + 2; }
inline int InlineQP(const int x) { return ((std::rand() % 2) ? InlineQO(x) : InlineQN(x)) + 2; }
inline int InlineQQ(const int x) { return ((std::rand() % 2) ? InlineQP(x) : InlineQO(x)) + 2; }
inline int InlineQR(const int x) { return ((std::rand() % 2) ? InlineQQ(x) : InlineQP(x)) + 2; }
inline int InlineQS(const int x) { return ((std::rand() % 2) ? InlineQR(x) : InlineQQ(x)) + 2; }
inline int InlineQT(const int x) { return ((std::rand() % 2) ? InlineQS(x) : InlineQR(x)) + 2; }
inline int InlineQU(const int x) { return ((std::rand() % 2) ? InlineQT(x) : InlineQS(x)) + 2; }
inline int InlineQV(const int x) { return ((std::rand() % 2) ? InlineQU(x) : InlineQT(x)) + 2; }
inline int InlineQW(const int x) { return ((std::rand() % 2) ? InlineQV(x) : InlineQU(x)) + 2; }
inline int InlineQX(const int x) { return ((std::rand() % 2) ? InlineQW(x) : InlineQV(x)) + 2; }
inline int InlineQY(const int x) { return ((std::rand() % 2) ? InlineQX(x) : InlineQW(x)) + 2; }
inline int InlineQZ(const int x) { return ((std::rand() % 2) ? InlineQY(x) : InlineQX(x)) + 2; }
inline int InlineRA(const int x) { return ((std::rand() % 2) ? InlineQZ(x) : InlineQY(x)) + 2; }
inline int InlineRB(const int x) { return ((std::rand() % 2) ? InlineRA(x) : InlineQZ(x)) + 2; }
inline int InlineRC(const int x) { return ((std::rand() % 2) ? InlineRB(x) : InlineRA(x)) + 2; }
inline int InlineRD(const int x) { return ((std::rand() % 2) ? InlineRC(x) : InlineRB(x)) + 2; }
inline int InlineRE(const int x) { return ((std::rand() % 2) ? InlineRD(x) : InlineRC(x)) + 2; }
inline int InlineRF(const int x) { return ((std::rand() % 2) ? InlineRE(x) : InlineRD(x)) + 2; }
inline int InlineRG(const int x) { return ((std::rand() % 2) ? InlineRF(x) : InlineRE(x)) + 2; }
inline int InlineRH(const int x) { return ((std::rand() % 2) ? InlineRG(x) : InlineRF(x)) + 2; }
inline int InlineRI(const int x) { return ((std::rand() % 2) ? InlineRH(x) : InlineRG(x)) + 2; }
inline int InlineRJ(const int x) { return ((std::rand() % 2) ? InlineRI(x) : InlineRH(x)) + 2; }
inline int InlineRK(const int x) { return ((std::rand() % 2) ? InlineRJ(x) : InlineRI(x)) + 2; }
inline int InlineRL(const int x) { return ((std::rand() % 2) ? InlineRK(x) : InlineRJ(x)) + 2; }
inline int InlineRM(const int x) { return ((std::rand() % 2) ? InlineRL(x) : InlineRK(x)) + 2; }
inline int InlineRN(const int x) { return ((std::rand() % 2) ? InlineRM(x) : InlineRL(x)) + 2; }
inline int InlineRO(const int x) { return ((std::rand() % 2) ? InlineRN(x) : InlineRM(x)) + 2; }
inline int InlineRP(const int x) { return ((std::rand() % 2) ? InlineRO(x) : InlineRN(x)) + 2; }
inline int InlineRQ(const int x) { return ((std::rand() % 2) ? InlineRP(x) : InlineRO(x)) + 2; }
inline int InlineRR(const int x) { return ((std::rand() % 2) ? InlineRQ(x) : InlineRP(x)) + 2; }
inline int InlineRS(const int x) { return ((std::rand() % 2) ? InlineRR(x) : InlineRQ(x)) + 2; }
inline int InlineRT(const int x) { return ((std::rand() % 2) ? InlineRS(x) : InlineRR(x)) + 2; }
inline int InlineRU(const int x) { return ((std::rand() % 2) ? InlineRT(x) : InlineRS(x)) + 2; }
inline int InlineRV(const int x) { return ((std::rand() % 2) ? InlineRU(x) : InlineRT(x)) + 2; }
inline int InlineRW(const int x) { return ((std::rand() % 2) ? InlineRV(x) : InlineRU(x)) + 2; }
inline int InlineRX(const int x) { return ((std::rand() % 2) ? InlineRW(x) : InlineRV(x)) + 2; }
inline int InlineRY(const int x) { return ((std::rand() % 2) ? InlineRX(x) : InlineRW(x)) + 2; }
inline int InlineRZ(const int x) { return ((std::rand() % 2) ? InlineRY(x) : InlineRX(x)) + 2; }
inline int InlineSA(const int x) { return ((std::rand() % 2) ? InlineRZ(x) : InlineRY(x)) + 2; }
inline int InlineSB(const int x) { return ((std::rand() % 2) ? InlineSA(x) : InlineRZ(x)) + 2; }
inline int InlineSC(const int x) { return ((std::rand() % 2) ? InlineSB(x) : InlineSA(x)) + 2; }
inline int InlineSD(const int x) { return ((std::rand() % 2) ? InlineSC(x) : InlineSB(x)) + 2; }
inline int InlineSE(const int x) { return ((std::rand() % 2) ? InlineSD(x) : InlineSC(x)) + 2; }
inline int InlineSF(const int x) { return ((std::rand() % 2) ? InlineSE(x) : InlineSD(x)) + 2; }
inline int InlineSG(const int x) { return ((std::rand() % 2) ? InlineSF(x) : InlineSE(x)) + 2; }
inline int InlineSH(const int x) { return ((std::rand() % 2) ? InlineSG(x) : InlineSF(x)) + 2; }
inline int InlineSI(const int x) { return ((std::rand() % 2) ? InlineSH(x) : InlineSG(x)) + 2; }
inline int InlineSJ(const int x) { return ((std::rand() % 2) ? InlineSI(x) : InlineSH(x)) + 2; }
inline int InlineSK(const int x) { return ((std::rand() % 2) ? InlineSJ(x) : InlineSI(x)) + 2; }
inline int InlineSL(const int x) { return ((std::rand() % 2) ? InlineSK(x) : InlineSJ(x)) + 2; }
inline int InlineSM(const int x) { return ((std::rand() % 2) ? InlineSL(x) : InlineSK(x)) + 2; }
inline int InlineSN(const int x) { return ((std::rand() % 2) ? InlineSM(x) : InlineSL(x)) + 2; }
inline int InlineSO(const int x) { return ((std::rand() % 2) ? InlineSN(x) : InlineSM(x)) + 2; }
inline int InlineSP(const int x) { return ((std::rand() % 2) ? InlineSO(x) : InlineSN(x)) + 2; }
inline int InlineSQ(const int x) { return ((std::rand() % 2) ? InlineSP(x) : InlineSO(x)) + 2; }
inline int InlineSR(const int x) { return ((std::rand() % 2) ? InlineSQ(x) : InlineSP(x)) + 2; }
inline int InlineSS(const int x) { return ((std::rand() % 2) ? InlineSR(x) : InlineSQ(x)) + 2; }
inline int InlineST(const int x) { return ((std::rand() % 2) ? InlineSS(x) : InlineSR(x)) + 2; }
inline int InlineSU(const int x) { return ((std::rand() % 2) ? InlineST(x) : InlineSS(x)) + 2; }
inline int InlineSV(const int x) { return ((std::rand() % 2) ? InlineSU(x) : InlineST(x)) + 2; }
inline int InlineSW(const int x) { return ((std::rand() % 2) ? InlineSV(x) : InlineSU(x)) + 2; }
inline int InlineSX(const int x) { return ((std::rand() % 2) ? InlineSW(x) : InlineSV(x)) + 2; }
inline int InlineSY(const int x) { return ((std::rand() % 2) ? InlineSX(x) : InlineSW(x)) + 2; }
inline int InlineSZ(const int x) { return ((std::rand() % 2) ? InlineSY(x) : InlineSX(x)) + 2; }
inline int InlineTA(const int x) { return ((std::rand() % 2) ? InlineSZ(x) : InlineSY(x)) + 2; }
inline int InlineTB(const int x) { return ((std::rand() % 2) ? InlineTA(x) : InlineSZ(x)) + 2; }
inline int InlineTC(const int x) { return ((std::rand() % 2) ? InlineTB(x) : InlineTA(x)) + 2; }
inline int InlineTD(const int x) { return ((std::rand() % 2) ? InlineTC(x) : InlineTB(x)) + 2; }
inline int InlineTE(const int x) { return ((std::rand() % 2) ? InlineTD(x) : InlineTC(x)) + 2; }
inline int InlineTF(const int x) { return ((std::rand() % 2) ? InlineTE(x) : InlineTD(x)) + 2; }
inline int InlineTG(const int x) { return ((std::rand() % 2) ? InlineTF(x) : InlineTE(x)) + 2; }
inline int InlineTH(const int x) { return ((std::rand() % 2) ? InlineTG(x) : InlineTF(x)) + 2; }
inline int InlineTI(const int x) { return ((std::rand() % 2) ? InlineTH(x) : InlineTG(x)) + 2; }
inline int InlineTJ(const int x) { return ((std::rand() % 2) ? InlineTI(x) : InlineTH(x)) + 2; }
inline int InlineTK(const int x) { return ((std::rand() % 2) ? InlineTJ(x) : InlineTI(x)) + 2; }
inline int InlineTL(const int x) { return ((std::rand() % 2) ? InlineTK(x) : InlineTJ(x)) + 2; }
inline int InlineTM(const int x) { return ((std::rand() % 2) ? InlineTL(x) : InlineTK(x)) + 2; }
inline int InlineTN(const int x) { return ((std::rand() % 2) ? InlineTM(x) : InlineTL(x)) + 2; }
inline int InlineTO(const int x) { return ((std::rand() % 2) ? InlineTN(x) : InlineTM(x)) + 2; }
inline int InlineTP(const int x) { return ((std::rand() % 2) ? InlineTO(x) : InlineTN(x)) + 2; }
inline int InlineTQ(const int x) { return ((std::rand() % 2) ? InlineTP(x) : InlineTO(x)) + 2; }
inline int InlineTR(const int x) { return ((std::rand() % 2) ? InlineTQ(x) : InlineTP(x)) + 2; }
inline int InlineTS(const int x) { return ((std::rand() % 2) ? InlineTR(x) : InlineTQ(x)) + 2; }
inline int InlineTT(const int x) { return ((std::rand() % 2) ? InlineTS(x) : InlineTR(x)) + 2; }
inline int InlineTU(const int x) { return ((std::rand() % 2) ? InlineTT(x) : InlineTS(x)) + 2; }
inline int InlineTV(const int x) { return ((std::rand() % 2) ? InlineTU(x) : InlineTT(x)) + 2; }
inline int InlineTW(const int x) { return ((std::rand() % 2) ? InlineTV(x) : InlineTU(x)) + 2; }
inline int InlineTX(const int x) { return ((std::rand() % 2) ? InlineTW(x) : InlineTV(x)) + 2; }
inline int InlineTY(const int x) { return ((std::rand() % 2) ? InlineTX(x) : InlineTW(x)) + 2; }
inline int InlineTZ(const int x) { return ((std::rand() % 2) ? InlineTY(x) : InlineTX(x)) + 2; }
inline int InlineUA(const int x) { return ((std::rand() % 2) ? InlineTZ(x) : InlineTY(x)) + 2; }
inline int InlineUB(const int x) { return ((std::rand() % 2) ? InlineUA(x) : InlineTZ(x)) + 2; }
inline int InlineUC(const int x) { return ((std::rand() % 2) ? InlineUB(x) : InlineUA(x)) + 2; }
inline int InlineUD(const int x) { return ((std::rand() % 2) ? InlineUC(x) : InlineUB(x)) + 2; }
inline int InlineUE(const int x) { return ((std::rand() % 2) ? InlineUD(x) : InlineUC(x)) + 2; }
inline int InlineUF(const int x) { return ((std::rand() % 2) ? InlineUE(x) : InlineUD(x)) + 2; }
inline int InlineUG(const int x) { return ((std::rand() % 2) ? InlineUF(x) : InlineUE(x)) + 2; }
inline int InlineUH(const int x) { return ((std::rand() % 2) ? InlineUG(x) : InlineUF(x)) + 2; }
inline int InlineUI(const int x) { return ((std::rand() % 2) ? InlineUH(x) : InlineUG(x)) + 2; }
inline int InlineUJ(const int x) { return ((std::rand() % 2) ? InlineUI(x) : InlineUH(x)) + 2; }
inline int InlineUK(const int x) { return ((std::rand() % 2) ? InlineUJ(x) : InlineUI(x)) + 2; }
inline int InlineUL(const int x) { return ((std::rand() % 2) ? InlineUK(x) : InlineUJ(x)) + 2; }
inline int InlineUM(const int x) { return ((std::rand() % 2) ? InlineUL(x) : InlineUK(x)) + 2; }
inline int InlineUN(const int x) { return ((std::rand() % 2) ? InlineUM(x) : InlineUL(x)) + 2; }
inline int InlineUO(const int x) { return ((std::rand() % 2) ? InlineUN(x) : InlineUM(x)) + 2; }
inline int InlineUP(const int x) { return ((std::rand() % 2) ? InlineUO(x) : InlineUN(x)) + 2; }
inline int InlineUQ(const int x) { return ((std::rand() % 2) ? InlineUP(x) : InlineUO(x)) + 2; }
inline int InlineUR(const int x) { return ((std::rand() % 2) ? InlineUQ(x) : InlineUP(x)) + 2; }
inline int InlineUS(const int x) { return ((std::rand() % 2) ? InlineUR(x) : InlineUQ(x)) + 2; }
inline int InlineUT(const int x) { return ((std::rand() % 2) ? InlineUS(x) : InlineUR(x)) + 2; }
inline int InlineUU(const int x) { return ((std::rand() % 2) ? InlineUT(x) : InlineUS(x)) + 2; }
inline int InlineUV(const int x) { return ((std::rand() % 2) ? InlineUU(x) : InlineUT(x)) + 2; }
inline int InlineUW(const int x) { return ((std::rand() % 2) ? InlineUV(x) : InlineUU(x)) + 2; }
inline int InlineUX(const int x) { return ((std::rand() % 2) ? InlineUW(x) : InlineUV(x)) + 2; }
inline int InlineUY(const int x) { return ((std::rand() % 2) ? InlineUX(x) : InlineUW(x)) + 2; }
inline int InlineUZ(const int x) { return ((std::rand() % 2) ? InlineUY(x) : InlineUX(x)) + 2; }
inline int InlineVA(const int x) { return ((std::rand() % 2) ? InlineUZ(x) : InlineUY(x)) + 2; }
inline int InlineVB(const int x) { return ((std::rand() % 2) ? InlineVA(x) : InlineUZ(x)) + 2; }
inline int InlineVC(const int x) { return ((std::rand() % 2) ? InlineVB(x) : InlineVA(x)) + 2; }
inline int InlineVD(const int x) { return ((std::rand() % 2) ? InlineVC(x) : InlineVB(x)) + 2; }
inline int InlineVE(const int x) { return ((std::rand() % 2) ? InlineVD(x) : InlineVC(x)) + 2; }
inline int InlineVF(const int x) { return ((std::rand() % 2) ? InlineVE(x) : InlineVD(x)) + 2; }
inline int InlineVG(const int x) { return ((std::rand() % 2) ? InlineVF(x) : InlineVE(x)) + 2; }
inline int InlineVH(const int x) { return ((std::rand() % 2) ? InlineVG(x) : InlineVF(x)) + 2; }
inline int InlineVI(const int x) { return ((std::rand() % 2) ? InlineVH(x) : InlineVG(x)) + 2; }
inline int InlineVJ(const int x) { return ((std::rand() % 2) ? InlineVI(x) : InlineVH(x)) + 2; }
inline int InlineVK(const int x) { return ((std::rand() % 2) ? InlineVJ(x) : InlineVI(x)) + 2; }
inline int InlineVL(const int x) { return ((std::rand() % 2) ? InlineVK(x) : InlineVJ(x)) + 2; }
inline int InlineVM(const int x) { return ((std::rand() % 2) ? InlineVL(x) : InlineVK(x)) + 2; }
inline int InlineVN(const int x) { return ((std::rand() % 2) ? InlineVM(x) : InlineVL(x)) + 2; }
inline int InlineVO(const int x) { return ((std::rand() % 2) ? InlineVN(x) : InlineVM(x)) + 2; }
inline int InlineVP(const int x) { return ((std::rand() % 2) ? InlineVO(x) : InlineVN(x)) + 2; }
inline int InlineVQ(const int x) { return ((std::rand() % 2) ? InlineVP(x) : InlineVO(x)) + 2; }
inline int InlineVR(const int x) { return ((std::rand() % 2) ? InlineVQ(x) : InlineVP(x)) + 2; }
inline int InlineVS(const int x) { return ((std::rand() % 2) ? InlineVR(x) : InlineVQ(x)) + 2; }
inline int InlineVT(const int x) { return ((std::rand() % 2) ? InlineVS(x) : InlineVR(x)) + 2; }
inline int InlineVU(const int x) { return ((std::rand() % 2) ? InlineVT(x) : InlineVS(x)) + 2; }
inline int InlineVV(const int x) { return ((std::rand() % 2) ? InlineVU(x) : InlineVT(x)) + 2; }
inline int InlineVW(const int x) { return ((std::rand() % 2) ? InlineVV(x) : InlineVU(x)) + 2; }
inline int InlineVX(const int x) { return ((std::rand() % 2) ? InlineVW(x) : InlineVV(x)) + 2; }
inline int InlineVY(const int x) { return ((std::rand() % 2) ? InlineVX(x) : InlineVW(x)) + 2; }
inline int InlineVZ(const int x) { return ((std::rand() % 2) ? InlineVY(x) : InlineVX(x)) + 2; }
inline int InlineWA(const int x) { return ((std::rand() % 2) ? InlineVZ(x) : InlineVY(x)) + 2; }
inline int InlineWB(const int x) { return ((std::rand() % 2) ? InlineWA(x) : InlineVZ(x)) + 2; }
inline int InlineWC(const int x) { return ((std::rand() % 2) ? InlineWB(x) : InlineWA(x)) + 2; }
inline int InlineWD(const int x) { return ((std::rand() % 2) ? InlineWC(x) : InlineWB(x)) + 2; }
inline int InlineWE(const int x) { return ((std::rand() % 2) ? InlineWD(x) : InlineWC(x)) + 2; }
inline int InlineWF(const int x) { return ((std::rand() % 2) ? InlineWE(x) : InlineWD(x)) + 2; }
inline int InlineWG(const int x) { return ((std::rand() % 2) ? InlineWF(x) : InlineWE(x)) + 2; }
inline int InlineWH(const int x) { return ((std::rand() % 2) ? InlineWG(x) : InlineWF(x)) + 2; }
inline int InlineWI(const int x) { return ((std::rand() % 2) ? InlineWH(x) : InlineWG(x)) + 2; }
inline int InlineWJ(const int x) { return ((std::rand() % 2) ? InlineWI(x) : InlineWH(x)) + 2; }
inline int InlineWK(const int x) { return ((std::rand() % 2) ? InlineWJ(x) : InlineWI(x)) + 2; }
inline int InlineWL(const int x) { return ((std::rand() % 2) ? InlineWK(x) : InlineWJ(x)) + 2; }
inline int InlineWM(const int x) { return ((std::rand() % 2) ? InlineWL(x) : InlineWK(x)) + 2; }
inline int InlineWN(const int x) { return ((std::rand() % 2) ? InlineWM(x) : InlineWL(x)) + 2; }
inline int InlineWO(const int x) { return ((std::rand() % 2) ? InlineWN(x) : InlineWM(x)) + 2; }
inline int InlineWP(const int x) { return ((std::rand() % 2) ? InlineWO(x) : InlineWN(x)) + 2; }
inline int InlineWQ(const int x) { return ((std::rand() % 2) ? InlineWP(x) : InlineWO(x)) + 2; }
inline int InlineWR(const int x) { return ((std::rand() % 2) ? InlineWQ(x) : InlineWP(x)) + 2; }
inline int InlineWS(const int x) { return ((std::rand() % 2) ? InlineWR(x) : InlineWQ(x)) + 2; }
inline int InlineWT(const int x) { return ((std::rand() % 2) ? InlineWS(x) : InlineWR(x)) + 2; }
inline int InlineWU(const int x) { return ((std::rand() % 2) ? InlineWT(x) : InlineWS(x)) + 2; }
inline int InlineWV(const int x) { return ((std::rand() % 2) ? InlineWU(x) : InlineWT(x)) + 2; }
inline int InlineWW(const int x) { return ((std::rand() % 2) ? InlineWV(x) : InlineWU(x)) + 2; }
inline int InlineWX(const int x) { return ((std::rand() % 2) ? InlineWW(x) : InlineWV(x)) + 2; }
inline int InlineWY(const int x) { return ((std::rand() % 2) ? InlineWX(x) : InlineWW(x)) + 2; }
inline int InlineWZ(const int x) { return ((std::rand() % 2) ? InlineWY(x) : InlineWX(x)) + 2; }
inline int InlineXA(const int x) { return ((std::rand() % 2) ? InlineWZ(x) : InlineWY(x)) + 2; }
inline int InlineXB(const int x) { return ((std::rand() % 2) ? InlineXA(x) : InlineWZ(x)) + 2; }
inline int InlineXC(const int x) { return ((std::rand() % 2) ? InlineXB(x) : InlineXA(x)) + 2; }
inline int InlineXD(const int x) { return ((std::rand() % 2) ? InlineXC(x) : InlineXB(x)) + 2; }
inline int InlineXE(const int x) { return ((std::rand() % 2) ? InlineXD(x) : InlineXC(x)) + 2; }
inline int InlineXF(const int x) { return ((std::rand() % 2) ? InlineXE(x) : InlineXD(x)) + 2; }
inline int InlineXG(const int x) { return ((std::rand() % 2) ? InlineXF(x) : InlineXE(x)) + 2; }
inline int InlineXH(const int x) { return ((std::rand() % 2) ? InlineXG(x) : InlineXF(x)) + 2; }
inline int InlineXI(const int x) { return ((std::rand() % 2) ? InlineXH(x) : InlineXG(x)) + 2; }
inline int InlineXJ(const int x) { return ((std::rand() % 2) ? InlineXI(x) : InlineXH(x)) + 2; }
inline int InlineXK(const int x) { return ((std::rand() % 2) ? InlineXJ(x) : InlineXI(x)) + 2; }
inline int InlineXL(const int x) { return ((std::rand() % 2) ? InlineXK(x) : InlineXJ(x)) + 2; }
inline int InlineXM(const int x) { return ((std::rand() % 2) ? InlineXL(x) : InlineXK(x)) + 2; }
inline int InlineXN(const int x) { return ((std::rand() % 2) ? InlineXM(x) : InlineXL(x)) + 2; }
inline int InlineXO(const int x) { return ((std::rand() % 2) ? InlineXN(x) : InlineXM(x)) + 2; }
inline int InlineXP(const int x) { return ((std::rand() % 2) ? InlineXO(x) : InlineXN(x)) + 2; }
inline int InlineXQ(const int x) { return ((std::rand() % 2) ? InlineXP(x) : InlineXO(x)) + 2; }
inline int InlineXR(const int x) { return ((std::rand() % 2) ? InlineXQ(x) : InlineXP(x)) + 2; }
inline int InlineXS(const int x) { return ((std::rand() % 2) ? InlineXR(x) : InlineXQ(x)) + 2; }
inline int InlineXT(const int x) { return ((std::rand() % 2) ? InlineXS(x) : InlineXR(x)) + 2; }
inline int InlineXU(const int x) { return ((std::rand() % 2) ? InlineXT(x) : InlineXS(x)) + 2; }
inline int InlineXV(const int x) { return ((std::rand() % 2) ? InlineXU(x) : InlineXT(x)) + 2; }
inline int InlineXW(const int x) { return ((std::rand() % 2) ? InlineXV(x) : InlineXU(x)) + 2; }
inline int InlineXX(const int x) { return ((std::rand() % 2) ? InlineXW(x) : InlineXV(x)) + 2; }
inline int InlineXY(const int x) { return ((std::rand() % 2) ? InlineXX(x) : InlineXW(x)) + 2; }
inline int InlineXZ(const int x) { return ((std::rand() % 2) ? InlineXY(x) : InlineXX(x)) + 2; }
inline int InlineYA(const int x) { return ((std::rand() % 2) ? InlineXZ(x) : InlineXY(x)) + 2; }
inline int InlineYB(const int x) { return ((std::rand() % 2) ? InlineYA(x) : InlineXZ(x)) + 2; }
inline int InlineYC(const int x) { return ((std::rand() % 2) ? InlineYB(x) : InlineYA(x)) + 2; }
inline int InlineYD(const int x) { return ((std::rand() % 2) ? InlineYC(x) : InlineYB(x)) + 2; }
inline int InlineYE(const int x) { return ((std::rand() % 2) ? InlineYD(x) : InlineYC(x)) + 2; }
inline int InlineYF(const int x) { return ((std::rand() % 2) ? InlineYE(x) : InlineYD(x)) + 2; }
inline int InlineYG(const int x) { return ((std::rand() % 2) ? InlineYF(x) : InlineYE(x)) + 2; }
inline int InlineYH(const int x) { return ((std::rand() % 2) ? InlineYG(x) : InlineYF(x)) + 2; }
inline int InlineYI(const int x) { return ((std::rand() % 2) ? InlineYH(x) : InlineYG(x)) + 2; }
inline int InlineYJ(const int x) { return ((std::rand() % 2) ? InlineYI(x) : InlineYH(x)) + 2; }
inline int InlineYK(const int x) { return ((std::rand() % 2) ? InlineYJ(x) : InlineYI(x)) + 2; }
inline int InlineYL(const int x) { return ((std::rand() % 2) ? InlineYK(x) : InlineYJ(x)) + 2; }
inline int InlineYM(const int x) { return ((std::rand() % 2) ? InlineYL(x) : InlineYK(x)) + 2; }
inline int InlineYN(const int x) { return ((std::rand() % 2) ? InlineYM(x) : InlineYL(x)) + 2; }
inline int InlineYO(const int x) { return ((std::rand() % 2) ? InlineYN(x) : InlineYM(x)) + 2; }
inline int InlineYP(const int x) { return ((std::rand() % 2) ? InlineYO(x) : InlineYN(x)) + 2; }
inline int InlineYQ(const int x) { return ((std::rand() % 2) ? InlineYP(x) : InlineYO(x)) + 2; }
inline int InlineYR(const int x) { return ((std::rand() % 2) ? InlineYQ(x) : InlineYP(x)) + 2; }
inline int InlineYS(const int x) { return ((std::rand() % 2) ? InlineYR(x) : InlineYQ(x)) + 2; }
inline int InlineYT(const int x) { return ((std::rand() % 2) ? InlineYS(x) : InlineYR(x)) + 2; }
inline int InlineYU(const int x) { return ((std::rand() % 2) ? InlineYT(x) : InlineYS(x)) + 2; }
inline int InlineYV(const int x) { return ((std::rand() % 2) ? InlineYU(x) : InlineYT(x)) + 2; }
inline int InlineYW(const int x) { return ((std::rand() % 2) ? InlineYV(x) : InlineYU(x)) + 2; }
inline int InlineYX(const int x) { return ((std::rand() % 2) ? InlineYW(x) : InlineYV(x)) + 2; }
inline int InlineYY(const int x) { return ((std::rand() % 2) ? InlineYX(x) : InlineYW(x)) + 2; }
inline int InlineYZ(const int x) { return ((std::rand() % 2) ? InlineYY(x) : InlineYX(x)) + 2; }
inline int InlineZA(const int x) { return ((std::rand() % 2) ? InlineYZ(x) : InlineYY(x)) + 2; }
inline int InlineZB(const int x) { return ((std::rand() % 2) ? InlineZA(x) : InlineYZ(x)) + 2; }
inline int InlineZC(const int x) { return ((std::rand() % 2) ? InlineZB(x) : InlineZA(x)) + 2; }
inline int InlineZD(const int x) { return ((std::rand() % 2) ? InlineZC(x) : InlineZB(x)) + 2; }
inline int InlineZE(const int x) { return ((std::rand() % 2) ? InlineZD(x) : InlineZC(x)) + 2; }
inline int InlineZF(const int x) { return ((std::rand() % 2) ? InlineZE(x) : InlineZD(x)) + 2; }
inline int InlineZG(const int x) { return ((std::rand() % 2) ? InlineZF(x) : InlineZE(x)) + 2; }
inline int InlineZH(const int x) { return ((std::rand() % 2) ? InlineZG(x) : InlineZF(x)) + 2; }
inline int InlineZI(const int x) { return ((std::rand() % 2) ? InlineZH(x) : InlineZG(x)) + 2; }
inline int InlineZJ(const int x) { return ((std::rand() % 2) ? InlineZI(x) : InlineZH(x)) + 2; }
inline int InlineZK(const int x) { return ((std::rand() % 2) ? InlineZJ(x) : InlineZI(x)) + 2; }
inline int InlineZL(const int x) { return ((std::rand() % 2) ? InlineZK(x) : InlineZJ(x)) + 2; }
inline int InlineZM(const int x) { return ((std::rand() % 2) ? InlineZL(x) : InlineZK(x)) + 2; }
inline int InlineZN(const int x) { return ((std::rand() % 2) ? InlineZM(x) : InlineZL(x)) + 2; }
inline int InlineZO(const int x) { return ((std::rand() % 2) ? InlineZN(x) : InlineZM(x)) + 2; }
inline int InlineZP(const int x) { return ((std::rand() % 2) ? InlineZO(x) : InlineZN(x)) + 2; }
inline int InlineZQ(const int x) { return ((std::rand() % 2) ? InlineZP(x) : InlineZO(x)) + 2; }
inline int InlineZR(const int x) { return ((std::rand() % 2) ? InlineZQ(x) : InlineZP(x)) + 2; }
inline int InlineZS(const int x) { return ((std::rand() % 2) ? InlineZR(x) : InlineZQ(x)) + 2; }
inline int InlineZT(const int x) { return ((std::rand() % 2) ? InlineZS(x) : InlineZR(x)) + 2; }
inline int InlineZU(const int x) { return ((std::rand() % 2) ? InlineZT(x) : InlineZS(x)) + 2; }
inline int InlineZV(const int x) { return ((std::rand() % 2) ? InlineZU(x) : InlineZT(x)) + 2; }
inline int InlineZW(const int x) { return ((std::rand() % 2) ? InlineZV(x) : InlineZU(x)) + 2; }
inline int InlineZX(const int x) { return ((std::rand() % 2) ? InlineZW(x) : InlineZV(x)) + 2; }
inline int InlineZY(const int x) { return ((std::rand() % 2) ? InlineZX(x) : InlineZW(x)) + 2; }
inline int InlineZZ(const int x) { return ((std::rand() % 2) ? InlineZY(x) : InlineZX(x)) + 2; }

int NonInlineAA(const int x) { return ((std::rand() % 2) ? 1 : 2 )+  x; }
int NonInlineAB(const int x) { return ((std::rand() % 2) ? NonInlineAA(x) : NonInlineAA(x)) +  2; }
int NonInlineAC(const int x) { return ((std::rand() % 2) ? NonInlineAB(x) : NonInlineAA(x)) + 2; }
int NonInlineAD(const int x) { return ((std::rand() % 2) ? NonInlineAC(x) : NonInlineAB(x)) + 2; }
int NonInlineAE(const int x) { return ((std::rand() % 2) ? NonInlineAD(x) : NonInlineAC(x)) + 2; }
int NonInlineAF(const int x) { return ((std::rand() % 2) ? NonInlineAE(x) : NonInlineAD(x)) + 2; }
int NonInlineAG(const int x) { return ((std::rand() % 2) ? NonInlineAF(x) : NonInlineAE(x)) + 2; }
int NonInlineAH(const int x) { return ((std::rand() % 2) ? NonInlineAG(x) : NonInlineAF(x)) + 2; }
int NonInlineAI(const int x) { return ((std::rand() % 2) ? NonInlineAH(x) : NonInlineAG(x)) + 2; }
int NonInlineAJ(const int x) { return ((std::rand() % 2) ? NonInlineAI(x) : NonInlineAH(x)) + 2; }
int NonInlineAK(const int x) { return ((std::rand() % 2) ? NonInlineAJ(x) : NonInlineAI(x)) + 2; }
int NonInlineAL(const int x) { return ((std::rand() % 2) ? NonInlineAK(x) : NonInlineAJ(x)) + 2; }
int NonInlineAM(const int x) { return ((std::rand() % 2) ? NonInlineAL(x) : NonInlineAK(x)) + 2; }
int NonInlineAN(const int x) { return ((std::rand() % 2) ? NonInlineAM(x) : NonInlineAL(x)) + 2; }
int NonInlineAO(const int x) { return ((std::rand() % 2) ? NonInlineAN(x) : NonInlineAM(x)) + 2; }
int NonInlineAP(const int x) { return ((std::rand() % 2) ? NonInlineAO(x) : NonInlineAN(x)) + 2; }
int NonInlineAQ(const int x) { return ((std::rand() % 2) ? NonInlineAP(x) : NonInlineAO(x)) + 2; }
int NonInlineAR(const int x) { return ((std::rand() % 2) ? NonInlineAQ(x) : NonInlineAP(x)) + 2; }
int NonInlineAS(const int x) { return ((std::rand() % 2) ? NonInlineAR(x) : NonInlineAQ(x)) + 2; }
int NonInlineAT(const int x) { return ((std::rand() % 2) ? NonInlineAS(x) : NonInlineAR(x)) + 2; }
int NonInlineAU(const int x) { return ((std::rand() % 2) ? NonInlineAT(x) : NonInlineAS(x)) + 2; }
int NonInlineAV(const int x) { return ((std::rand() % 2) ? NonInlineAU(x) : NonInlineAT(x)) + 2; }
int NonInlineAW(const int x) { return ((std::rand() % 2) ? NonInlineAV(x) : NonInlineAU(x)) + 2; }
int NonInlineAX(const int x) { return ((std::rand() % 2) ? NonInlineAW(x) : NonInlineAV(x)) + 2; }
int NonInlineAY(const int x) { return ((std::rand() % 2) ? NonInlineAX(x) : NonInlineAW(x)) + 2; }
int NonInlineAZ(const int x) { return ((std::rand() % 2) ? NonInlineAY(x) : NonInlineAX(x)) + 2; }
int NonInlineBA(const int x) { return ((std::rand() % 2) ? NonInlineAZ(x) : NonInlineAY(x)) + 2; }
int NonInlineBB(const int x) { return ((std::rand() % 2) ? NonInlineBA(x) : NonInlineAZ(x)) + 2; }
int NonInlineBC(const int x) { return ((std::rand() % 2) ? NonInlineBB(x) : NonInlineBA(x)) + 2; }
int NonInlineBD(const int x) { return ((std::rand() % 2) ? NonInlineBC(x) : NonInlineBB(x)) + 2; }
int NonInlineBE(const int x) { return ((std::rand() % 2) ? NonInlineBD(x) : NonInlineBC(x)) + 2; }
int NonInlineBF(const int x) { return ((std::rand() % 2) ? NonInlineBE(x) : NonInlineBD(x)) + 2; }
int NonInlineBG(const int x) { return ((std::rand() % 2) ? NonInlineBF(x) : NonInlineBE(x)) + 2; }
int NonInlineBH(const int x) { return ((std::rand() % 2) ? NonInlineBG(x) : NonInlineBF(x)) + 2; }
int NonInlineBI(const int x) { return ((std::rand() % 2) ? NonInlineBH(x) : NonInlineBG(x)) + 2; }
int NonInlineBJ(const int x) { return ((std::rand() % 2) ? NonInlineBI(x) : NonInlineBH(x)) + 2; }
int NonInlineBK(const int x) { return ((std::rand() % 2) ? NonInlineBJ(x) : NonInlineBI(x)) + 2; }
int NonInlineBL(const int x) { return ((std::rand() % 2) ? NonInlineBK(x) : NonInlineBJ(x)) + 2; }
int NonInlineBM(const int x) { return ((std::rand() % 2) ? NonInlineBL(x) : NonInlineBK(x)) + 2; }
int NonInlineBN(const int x) { return ((std::rand() % 2) ? NonInlineBM(x) : NonInlineBL(x)) + 2; }
int NonInlineBO(const int x) { return ((std::rand() % 2) ? NonInlineBN(x) : NonInlineBM(x)) + 2; }
int NonInlineBP(const int x) { return ((std::rand() % 2) ? NonInlineBO(x) : NonInlineBN(x)) + 2; }
int NonInlineBQ(const int x) { return ((std::rand() % 2) ? NonInlineBP(x) : NonInlineBO(x)) + 2; }
int NonInlineBR(const int x) { return ((std::rand() % 2) ? NonInlineBQ(x) : NonInlineBP(x)) + 2; }
int NonInlineBS(const int x) { return ((std::rand() % 2) ? NonInlineBR(x) : NonInlineBQ(x)) + 2; }
int NonInlineBT(const int x) { return ((std::rand() % 2) ? NonInlineBS(x) : NonInlineBR(x)) + 2; }
int NonInlineBU(const int x) { return ((std::rand() % 2) ? NonInlineBT(x) : NonInlineBS(x)) + 2; }
int NonInlineBV(const int x) { return ((std::rand() % 2) ? NonInlineBU(x) : NonInlineBT(x)) + 2; }
int NonInlineBW(const int x) { return ((std::rand() % 2) ? NonInlineBV(x) : NonInlineBU(x)) + 2; }
int NonInlineBX(const int x) { return ((std::rand() % 2) ? NonInlineBW(x) : NonInlineBV(x)) + 2; }
int NonInlineBY(const int x) { return ((std::rand() % 2) ? NonInlineBX(x) : NonInlineBW(x)) + 2; }
int NonInlineBZ(const int x) { return ((std::rand() % 2) ? NonInlineBY(x) : NonInlineBX(x)) + 2; }
int NonInlineCA(const int x) { return ((std::rand() % 2) ? NonInlineBZ(x) : NonInlineBY(x)) + 2; }
int NonInlineCB(const int x) { return ((std::rand() % 2) ? NonInlineCA(x) : NonInlineBZ(x)) + 2; }
int NonInlineCC(const int x) { return ((std::rand() % 2) ? NonInlineCB(x) : NonInlineCA(x)) + 2; }
int NonInlineCD(const int x) { return ((std::rand() % 2) ? NonInlineCC(x) : NonInlineCB(x)) + 2; }
int NonInlineCE(const int x) { return ((std::rand() % 2) ? NonInlineCD(x) : NonInlineCC(x)) + 2; }
int NonInlineCF(const int x) { return ((std::rand() % 2) ? NonInlineCE(x) : NonInlineCD(x)) + 2; }
int NonInlineCG(const int x) { return ((std::rand() % 2) ? NonInlineCF(x) : NonInlineCE(x)) + 2; }
int NonInlineCH(const int x) { return ((std::rand() % 2) ? NonInlineCG(x) : NonInlineCF(x)) + 2; }
int NonInlineCI(const int x) { return ((std::rand() % 2) ? NonInlineCH(x) : NonInlineCG(x)) + 2; }
int NonInlineCJ(const int x) { return ((std::rand() % 2) ? NonInlineCI(x) : NonInlineCH(x)) + 2; }
int NonInlineCK(const int x) { return ((std::rand() % 2) ? NonInlineCJ(x) : NonInlineCI(x)) + 2; }
int NonInlineCL(const int x) { return ((std::rand() % 2) ? NonInlineCK(x) : NonInlineCJ(x)) + 2; }
int NonInlineCM(const int x) { return ((std::rand() % 2) ? NonInlineCL(x) : NonInlineCK(x)) + 2; }
int NonInlineCN(const int x) { return ((std::rand() % 2) ? NonInlineCM(x) : NonInlineCL(x)) + 2; }
int NonInlineCO(const int x) { return ((std::rand() % 2) ? NonInlineCN(x) : NonInlineCM(x)) + 2; }
int NonInlineCP(const int x) { return ((std::rand() % 2) ? NonInlineCO(x) : NonInlineCN(x)) + 2; }
int NonInlineCQ(const int x) { return ((std::rand() % 2) ? NonInlineCP(x) : NonInlineCO(x)) + 2; }
int NonInlineCR(const int x) { return ((std::rand() % 2) ? NonInlineCQ(x) : NonInlineCP(x)) + 2; }
int NonInlineCS(const int x) { return ((std::rand() % 2) ? NonInlineCR(x) : NonInlineCQ(x)) + 2; }
int NonInlineCT(const int x) { return ((std::rand() % 2) ? NonInlineCS(x) : NonInlineCR(x)) + 2; }
int NonInlineCU(const int x) { return ((std::rand() % 2) ? NonInlineCT(x) : NonInlineCS(x)) + 2; }
int NonInlineCV(const int x) { return ((std::rand() % 2) ? NonInlineCU(x) : NonInlineCT(x)) + 2; }
int NonInlineCW(const int x) { return ((std::rand() % 2) ? NonInlineCV(x) : NonInlineCU(x)) + 2; }
int NonInlineCX(const int x) { return ((std::rand() % 2) ? NonInlineCW(x) : NonInlineCV(x)) + 2; }
int NonInlineCY(const int x) { return ((std::rand() % 2) ? NonInlineCX(x) : NonInlineCW(x)) + 2; }
int NonInlineCZ(const int x) { return ((std::rand() % 2) ? NonInlineCY(x) : NonInlineCX(x)) + 2; }
int NonInlineDA(const int x) { return ((std::rand() % 2) ? NonInlineCZ(x) : NonInlineCY(x)) + 2; }
int NonInlineDB(const int x) { return ((std::rand() % 2) ? NonInlineDA(x) : NonInlineCZ(x)) + 2; }
int NonInlineDC(const int x) { return ((std::rand() % 2) ? NonInlineDB(x) : NonInlineDA(x)) + 2; }
int NonInlineDD(const int x) { return ((std::rand() % 2) ? NonInlineDC(x) : NonInlineDB(x)) + 2; }
int NonInlineDE(const int x) { return ((std::rand() % 2) ? NonInlineDD(x) : NonInlineDC(x)) + 2; }
int NonInlineDF(const int x) { return ((std::rand() % 2) ? NonInlineDE(x) : NonInlineDD(x)) + 2; }
int NonInlineDG(const int x) { return ((std::rand() % 2) ? NonInlineDF(x) : NonInlineDE(x)) + 2; }
int NonInlineDH(const int x) { return ((std::rand() % 2) ? NonInlineDG(x) : NonInlineDF(x)) + 2; }
int NonInlineDI(const int x) { return ((std::rand() % 2) ? NonInlineDH(x) : NonInlineDG(x)) + 2; }
int NonInlineDJ(const int x) { return ((std::rand() % 2) ? NonInlineDI(x) : NonInlineDH(x)) + 2; }
int NonInlineDK(const int x) { return ((std::rand() % 2) ? NonInlineDJ(x) : NonInlineDI(x)) + 2; }
int NonInlineDL(const int x) { return ((std::rand() % 2) ? NonInlineDK(x) : NonInlineDJ(x)) + 2; }
int NonInlineDM(const int x) { return ((std::rand() % 2) ? NonInlineDL(x) : NonInlineDK(x)) + 2; }
int NonInlineDN(const int x) { return ((std::rand() % 2) ? NonInlineDM(x) : NonInlineDL(x)) + 2; }
int NonInlineDO(const int x) { return ((std::rand() % 2) ? NonInlineDN(x) : NonInlineDM(x)) + 2; }
int NonInlineDP(const int x) { return ((std::rand() % 2) ? NonInlineDO(x) : NonInlineDN(x)) + 2; }
int NonInlineDQ(const int x) { return ((std::rand() % 2) ? NonInlineDP(x) : NonInlineDO(x)) + 2; }
int NonInlineDR(const int x) { return ((std::rand() % 2) ? NonInlineDQ(x) : NonInlineDP(x)) + 2; }
int NonInlineDS(const int x) { return ((std::rand() % 2) ? NonInlineDR(x) : NonInlineDQ(x)) + 2; }
int NonInlineDT(const int x) { return ((std::rand() % 2) ? NonInlineDS(x) : NonInlineDR(x)) + 2; }
int NonInlineDU(const int x) { return ((std::rand() % 2) ? NonInlineDT(x) : NonInlineDS(x)) + 2; }
int NonInlineDV(const int x) { return ((std::rand() % 2) ? NonInlineDU(x) : NonInlineDT(x)) + 2; }
int NonInlineDW(const int x) { return ((std::rand() % 2) ? NonInlineDV(x) : NonInlineDU(x)) + 2; }
int NonInlineDX(const int x) { return ((std::rand() % 2) ? NonInlineDW(x) : NonInlineDV(x)) + 2; }
int NonInlineDY(const int x) { return ((std::rand() % 2) ? NonInlineDX(x) : NonInlineDW(x)) + 2; }
int NonInlineDZ(const int x) { return ((std::rand() % 2) ? NonInlineDY(x) : NonInlineDX(x)) + 2; }
int NonInlineEA(const int x) { return ((std::rand() % 2) ? NonInlineDZ(x) : NonInlineDY(x)) + 2; }
int NonInlineEB(const int x) { return ((std::rand() % 2) ? NonInlineEA(x) : NonInlineDZ(x)) + 2; }
int NonInlineEC(const int x) { return ((std::rand() % 2) ? NonInlineEB(x) : NonInlineEA(x)) + 2; }
int NonInlineED(const int x) { return ((std::rand() % 2) ? NonInlineEC(x) : NonInlineEB(x)) + 2; }
int NonInlineEE(const int x) { return ((std::rand() % 2) ? NonInlineED(x) : NonInlineEC(x)) + 2; }
int NonInlineEF(const int x) { return ((std::rand() % 2) ? NonInlineEE(x) : NonInlineED(x)) + 2; }
int NonInlineEG(const int x) { return ((std::rand() % 2) ? NonInlineEF(x) : NonInlineEE(x)) + 2; }
int NonInlineEH(const int x) { return ((std::rand() % 2) ? NonInlineEG(x) : NonInlineEF(x)) + 2; }
int NonInlineEI(const int x) { return ((std::rand() % 2) ? NonInlineEH(x) : NonInlineEG(x)) + 2; }
int NonInlineEJ(const int x) { return ((std::rand() % 2) ? NonInlineEI(x) : NonInlineEH(x)) + 2; }
int NonInlineEK(const int x) { return ((std::rand() % 2) ? NonInlineEJ(x) : NonInlineEI(x)) + 2; }
int NonInlineEL(const int x) { return ((std::rand() % 2) ? NonInlineEK(x) : NonInlineEJ(x)) + 2; }
int NonInlineEM(const int x) { return ((std::rand() % 2) ? NonInlineEL(x) : NonInlineEK(x)) + 2; }
int NonInlineEN(const int x) { return ((std::rand() % 2) ? NonInlineEM(x) : NonInlineEL(x)) + 2; }
int NonInlineEO(const int x) { return ((std::rand() % 2) ? NonInlineEN(x) : NonInlineEM(x)) + 2; }
int NonInlineEP(const int x) { return ((std::rand() % 2) ? NonInlineEO(x) : NonInlineEN(x)) + 2; }
int NonInlineEQ(const int x) { return ((std::rand() % 2) ? NonInlineEP(x) : NonInlineEO(x)) + 2; }
int NonInlineER(const int x) { return ((std::rand() % 2) ? NonInlineEQ(x) : NonInlineEP(x)) + 2; }
int NonInlineES(const int x) { return ((std::rand() % 2) ? NonInlineER(x) : NonInlineEQ(x)) + 2; }
int NonInlineET(const int x) { return ((std::rand() % 2) ? NonInlineES(x) : NonInlineER(x)) + 2; }
int NonInlineEU(const int x) { return ((std::rand() % 2) ? NonInlineET(x) : NonInlineES(x)) + 2; }
int NonInlineEV(const int x) { return ((std::rand() % 2) ? NonInlineEU(x) : NonInlineET(x)) + 2; }
int NonInlineEW(const int x) { return ((std::rand() % 2) ? NonInlineEV(x) : NonInlineEU(x)) + 2; }
int NonInlineEX(const int x) { return ((std::rand() % 2) ? NonInlineEW(x) : NonInlineEV(x)) + 2; }
int NonInlineEY(const int x) { return ((std::rand() % 2) ? NonInlineEX(x) : NonInlineEW(x)) + 2; }
int NonInlineEZ(const int x) { return ((std::rand() % 2) ? NonInlineEY(x) : NonInlineEX(x)) + 2; }
int NonInlineFA(const int x) { return ((std::rand() % 2) ? NonInlineEZ(x) : NonInlineEY(x)) + 2; }
int NonInlineFB(const int x) { return ((std::rand() % 2) ? NonInlineFA(x) : NonInlineEZ(x)) + 2; }
int NonInlineFC(const int x) { return ((std::rand() % 2) ? NonInlineFB(x) : NonInlineFA(x)) + 2; }
int NonInlineFD(const int x) { return ((std::rand() % 2) ? NonInlineFC(x) : NonInlineFB(x)) + 2; }
int NonInlineFE(const int x) { return ((std::rand() % 2) ? NonInlineFD(x) : NonInlineFC(x)) + 2; }
int NonInlineFF(const int x) { return ((std::rand() % 2) ? NonInlineFE(x) : NonInlineFD(x)) + 2; }
int NonInlineFG(const int x) { return ((std::rand() % 2) ? NonInlineFF(x) : NonInlineFE(x)) + 2; }
int NonInlineFH(const int x) { return ((std::rand() % 2) ? NonInlineFG(x) : NonInlineFF(x)) + 2; }
int NonInlineFI(const int x) { return ((std::rand() % 2) ? NonInlineFH(x) : NonInlineFG(x)) + 2; }
int NonInlineFJ(const int x) { return ((std::rand() % 2) ? NonInlineFI(x) : NonInlineFH(x)) + 2; }
int NonInlineFK(const int x) { return ((std::rand() % 2) ? NonInlineFJ(x) : NonInlineFI(x)) + 2; }
int NonInlineFL(const int x) { return ((std::rand() % 2) ? NonInlineFK(x) : NonInlineFJ(x)) + 2; }
int NonInlineFM(const int x) { return ((std::rand() % 2) ? NonInlineFL(x) : NonInlineFK(x)) + 2; }
int NonInlineFN(const int x) { return ((std::rand() % 2) ? NonInlineFM(x) : NonInlineFL(x)) + 2; }
int NonInlineFO(const int x) { return ((std::rand() % 2) ? NonInlineFN(x) : NonInlineFM(x)) + 2; }
int NonInlineFP(const int x) { return ((std::rand() % 2) ? NonInlineFO(x) : NonInlineFN(x)) + 2; }
int NonInlineFQ(const int x) { return ((std::rand() % 2) ? NonInlineFP(x) : NonInlineFO(x)) + 2; }
int NonInlineFR(const int x) { return ((std::rand() % 2) ? NonInlineFQ(x) : NonInlineFP(x)) + 2; }
int NonInlineFS(const int x) { return ((std::rand() % 2) ? NonInlineFR(x) : NonInlineFQ(x)) + 2; }
int NonInlineFT(const int x) { return ((std::rand() % 2) ? NonInlineFS(x) : NonInlineFR(x)) + 2; }
int NonInlineFU(const int x) { return ((std::rand() % 2) ? NonInlineFT(x) : NonInlineFS(x)) + 2; }
int NonInlineFV(const int x) { return ((std::rand() % 2) ? NonInlineFU(x) : NonInlineFT(x)) + 2; }
int NonInlineFW(const int x) { return ((std::rand() % 2) ? NonInlineFV(x) : NonInlineFU(x)) + 2; }
int NonInlineFX(const int x) { return ((std::rand() % 2) ? NonInlineFW(x) : NonInlineFV(x)) + 2; }
int NonInlineFY(const int x) { return ((std::rand() % 2) ? NonInlineFX(x) : NonInlineFW(x)) + 2; }
int NonInlineFZ(const int x) { return ((std::rand() % 2) ? NonInlineFY(x) : NonInlineFX(x)) + 2; }
int NonInlineGA(const int x) { return ((std::rand() % 2) ? NonInlineFZ(x) : NonInlineFY(x)) + 2; }
int NonInlineGB(const int x) { return ((std::rand() % 2) ? NonInlineGA(x) : NonInlineFZ(x)) + 2; }
int NonInlineGC(const int x) { return ((std::rand() % 2) ? NonInlineGB(x) : NonInlineGA(x)) + 2; }
int NonInlineGD(const int x) { return ((std::rand() % 2) ? NonInlineGC(x) : NonInlineGB(x)) + 2; }
int NonInlineGE(const int x) { return ((std::rand() % 2) ? NonInlineGD(x) : NonInlineGC(x)) + 2; }
int NonInlineGF(const int x) { return ((std::rand() % 2) ? NonInlineGE(x) : NonInlineGD(x)) + 2; }
int NonInlineGG(const int x) { return ((std::rand() % 2) ? NonInlineGF(x) : NonInlineGE(x)) + 2; }
int NonInlineGH(const int x) { return ((std::rand() % 2) ? NonInlineGG(x) : NonInlineGF(x)) + 2; }
int NonInlineGI(const int x) { return ((std::rand() % 2) ? NonInlineGH(x) : NonInlineGG(x)) + 2; }
int NonInlineGJ(const int x) { return ((std::rand() % 2) ? NonInlineGI(x) : NonInlineGH(x)) + 2; }
int NonInlineGK(const int x) { return ((std::rand() % 2) ? NonInlineGJ(x) : NonInlineGI(x)) + 2; }
int NonInlineGL(const int x) { return ((std::rand() % 2) ? NonInlineGK(x) : NonInlineGJ(x)) + 2; }
int NonInlineGM(const int x) { return ((std::rand() % 2) ? NonInlineGL(x) : NonInlineGK(x)) + 2; }
int NonInlineGN(const int x) { return ((std::rand() % 2) ? NonInlineGM(x) : NonInlineGL(x)) + 2; }
int NonInlineGO(const int x) { return ((std::rand() % 2) ? NonInlineGN(x) : NonInlineGM(x)) + 2; }
int NonInlineGP(const int x) { return ((std::rand() % 2) ? NonInlineGO(x) : NonInlineGN(x)) + 2; }
int NonInlineGQ(const int x) { return ((std::rand() % 2) ? NonInlineGP(x) : NonInlineGO(x)) + 2; }
int NonInlineGR(const int x) { return ((std::rand() % 2) ? NonInlineGQ(x) : NonInlineGP(x)) + 2; }
int NonInlineGS(const int x) { return ((std::rand() % 2) ? NonInlineGR(x) : NonInlineGQ(x)) + 2; }
int NonInlineGT(const int x) { return ((std::rand() % 2) ? NonInlineGS(x) : NonInlineGR(x)) + 2; }
int NonInlineGU(const int x) { return ((std::rand() % 2) ? NonInlineGT(x) : NonInlineGS(x)) + 2; }
int NonInlineGV(const int x) { return ((std::rand() % 2) ? NonInlineGU(x) : NonInlineGT(x)) + 2; }
int NonInlineGW(const int x) { return ((std::rand() % 2) ? NonInlineGV(x) : NonInlineGU(x)) + 2; }
int NonInlineGX(const int x) { return ((std::rand() % 2) ? NonInlineGW(x) : NonInlineGV(x)) + 2; }
int NonInlineGY(const int x) { return ((std::rand() % 2) ? NonInlineGX(x) : NonInlineGW(x)) + 2; }
int NonInlineGZ(const int x) { return ((std::rand() % 2) ? NonInlineGY(x) : NonInlineGX(x)) + 2; }
int NonInlineHA(const int x) { return ((std::rand() % 2) ? NonInlineGZ(x) : NonInlineGY(x)) + 2; }
int NonInlineHB(const int x) { return ((std::rand() % 2) ? NonInlineHA(x) : NonInlineGZ(x)) + 2; }
int NonInlineHC(const int x) { return ((std::rand() % 2) ? NonInlineHB(x) : NonInlineHA(x)) + 2; }
int NonInlineHD(const int x) { return ((std::rand() % 2) ? NonInlineHC(x) : NonInlineHB(x)) + 2; }
int NonInlineHE(const int x) { return ((std::rand() % 2) ? NonInlineHD(x) : NonInlineHC(x)) + 2; }
int NonInlineHF(const int x) { return ((std::rand() % 2) ? NonInlineHE(x) : NonInlineHD(x)) + 2; }
int NonInlineHG(const int x) { return ((std::rand() % 2) ? NonInlineHF(x) : NonInlineHE(x)) + 2; }
int NonInlineHH(const int x) { return ((std::rand() % 2) ? NonInlineHG(x) : NonInlineHF(x)) + 2; }
int NonInlineHI(const int x) { return ((std::rand() % 2) ? NonInlineHH(x) : NonInlineHG(x)) + 2; }
int NonInlineHJ(const int x) { return ((std::rand() % 2) ? NonInlineHI(x) : NonInlineHH(x)) + 2; }
int NonInlineHK(const int x) { return ((std::rand() % 2) ? NonInlineHJ(x) : NonInlineHI(x)) + 2; }
int NonInlineHL(const int x) { return ((std::rand() % 2) ? NonInlineHK(x) : NonInlineHJ(x)) + 2; }
int NonInlineHM(const int x) { return ((std::rand() % 2) ? NonInlineHL(x) : NonInlineHK(x)) + 2; }
int NonInlineHN(const int x) { return ((std::rand() % 2) ? NonInlineHM(x) : NonInlineHL(x)) + 2; }
int NonInlineHO(const int x) { return ((std::rand() % 2) ? NonInlineHN(x) : NonInlineHM(x)) + 2; }
int NonInlineHP(const int x) { return ((std::rand() % 2) ? NonInlineHO(x) : NonInlineHN(x)) + 2; }
int NonInlineHQ(const int x) { return ((std::rand() % 2) ? NonInlineHP(x) : NonInlineHO(x)) + 2; }
int NonInlineHR(const int x) { return ((std::rand() % 2) ? NonInlineHQ(x) : NonInlineHP(x)) + 2; }
int NonInlineHS(const int x) { return ((std::rand() % 2) ? NonInlineHR(x) : NonInlineHQ(x)) + 2; }
int NonInlineHT(const int x) { return ((std::rand() % 2) ? NonInlineHS(x) : NonInlineHR(x)) + 2; }
int NonInlineHU(const int x) { return ((std::rand() % 2) ? NonInlineHT(x) : NonInlineHS(x)) + 2; }
int NonInlineHV(const int x) { return ((std::rand() % 2) ? NonInlineHU(x) : NonInlineHT(x)) + 2; }
int NonInlineHW(const int x) { return ((std::rand() % 2) ? NonInlineHV(x) : NonInlineHU(x)) + 2; }
int NonInlineHX(const int x) { return ((std::rand() % 2) ? NonInlineHW(x) : NonInlineHV(x)) + 2; }
int NonInlineHY(const int x) { return ((std::rand() % 2) ? NonInlineHX(x) : NonInlineHW(x)) + 2; }
int NonInlineHZ(const int x) { return ((std::rand() % 2) ? NonInlineHY(x) : NonInlineHX(x)) + 2; }
int NonInlineIA(const int x) { return ((std::rand() % 2) ? NonInlineHZ(x) : NonInlineHY(x)) + 2; }
int NonInlineIB(const int x) { return ((std::rand() % 2) ? NonInlineIA(x) : NonInlineHZ(x)) + 2; }
int NonInlineIC(const int x) { return ((std::rand() % 2) ? NonInlineIB(x) : NonInlineIA(x)) + 2; }
int NonInlineID(const int x) { return ((std::rand() % 2) ? NonInlineIC(x) : NonInlineIB(x)) + 2; }
int NonInlineIE(const int x) { return ((std::rand() % 2) ? NonInlineID(x) : NonInlineIC(x)) + 2; }
int NonInlineIF(const int x) { return ((std::rand() % 2) ? NonInlineIE(x) : NonInlineID(x)) + 2; }
int NonInlineIG(const int x) { return ((std::rand() % 2) ? NonInlineIF(x) : NonInlineIE(x)) + 2; }
int NonInlineIH(const int x) { return ((std::rand() % 2) ? NonInlineIG(x) : NonInlineIF(x)) + 2; }
int NonInlineII(const int x) { return ((std::rand() % 2) ? NonInlineIH(x) : NonInlineIG(x)) + 2; }
int NonInlineIJ(const int x) { return ((std::rand() % 2) ? NonInlineII(x) : NonInlineIH(x)) + 2; }
int NonInlineIK(const int x) { return ((std::rand() % 2) ? NonInlineIJ(x) : NonInlineII(x)) + 2; }
int NonInlineIL(const int x) { return ((std::rand() % 2) ? NonInlineIK(x) : NonInlineIJ(x)) + 2; }
int NonInlineIM(const int x) { return ((std::rand() % 2) ? NonInlineIL(x) : NonInlineIK(x)) + 2; }
int NonInlineIN(const int x) { return ((std::rand() % 2) ? NonInlineIM(x) : NonInlineIL(x)) + 2; }
int NonInlineIO(const int x) { return ((std::rand() % 2) ? NonInlineIN(x) : NonInlineIM(x)) + 2; }
int NonInlineIP(const int x) { return ((std::rand() % 2) ? NonInlineIO(x) : NonInlineIN(x)) + 2; }
int NonInlineIQ(const int x) { return ((std::rand() % 2) ? NonInlineIP(x) : NonInlineIO(x)) + 2; }
int NonInlineIR(const int x) { return ((std::rand() % 2) ? NonInlineIQ(x) : NonInlineIP(x)) + 2; }
int NonInlineIS(const int x) { return ((std::rand() % 2) ? NonInlineIR(x) : NonInlineIQ(x)) + 2; }
int NonInlineIT(const int x) { return ((std::rand() % 2) ? NonInlineIS(x) : NonInlineIR(x)) + 2; }
int NonInlineIU(const int x) { return ((std::rand() % 2) ? NonInlineIT(x) : NonInlineIS(x)) + 2; }
int NonInlineIV(const int x) { return ((std::rand() % 2) ? NonInlineIU(x) : NonInlineIT(x)) + 2; }
int NonInlineIW(const int x) { return ((std::rand() % 2) ? NonInlineIV(x) : NonInlineIU(x)) + 2; }
int NonInlineIX(const int x) { return ((std::rand() % 2) ? NonInlineIW(x) : NonInlineIV(x)) + 2; }
int NonInlineIY(const int x) { return ((std::rand() % 2) ? NonInlineIX(x) : NonInlineIW(x)) + 2; }
int NonInlineIZ(const int x) { return ((std::rand() % 2) ? NonInlineIY(x) : NonInlineIX(x)) + 2; }
int NonInlineJA(const int x) { return ((std::rand() % 2) ? NonInlineIZ(x) : NonInlineIY(x)) + 2; }
int NonInlineJB(const int x) { return ((std::rand() % 2) ? NonInlineJA(x) : NonInlineIZ(x)) + 2; }
int NonInlineJC(const int x) { return ((std::rand() % 2) ? NonInlineJB(x) : NonInlineJA(x)) + 2; }
int NonInlineJD(const int x) { return ((std::rand() % 2) ? NonInlineJC(x) : NonInlineJB(x)) + 2; }
int NonInlineJE(const int x) { return ((std::rand() % 2) ? NonInlineJD(x) : NonInlineJC(x)) + 2; }
int NonInlineJF(const int x) { return ((std::rand() % 2) ? NonInlineJE(x) : NonInlineJD(x)) + 2; }
int NonInlineJG(const int x) { return ((std::rand() % 2) ? NonInlineJF(x) : NonInlineJE(x)) + 2; }
int NonInlineJH(const int x) { return ((std::rand() % 2) ? NonInlineJG(x) : NonInlineJF(x)) + 2; }
int NonInlineJI(const int x) { return ((std::rand() % 2) ? NonInlineJH(x) : NonInlineJG(x)) + 2; }
int NonInlineJJ(const int x) { return ((std::rand() % 2) ? NonInlineJI(x) : NonInlineJH(x)) + 2; }
int NonInlineJK(const int x) { return ((std::rand() % 2) ? NonInlineJJ(x) : NonInlineJI(x)) + 2; }
int NonInlineJL(const int x) { return ((std::rand() % 2) ? NonInlineJK(x) : NonInlineJJ(x)) + 2; }
int NonInlineJM(const int x) { return ((std::rand() % 2) ? NonInlineJL(x) : NonInlineJK(x)) + 2; }
int NonInlineJN(const int x) { return ((std::rand() % 2) ? NonInlineJM(x) : NonInlineJL(x)) + 2; }
int NonInlineJO(const int x) { return ((std::rand() % 2) ? NonInlineJN(x) : NonInlineJM(x)) + 2; }
int NonInlineJP(const int x) { return ((std::rand() % 2) ? NonInlineJO(x) : NonInlineJN(x)) + 2; }
int NonInlineJQ(const int x) { return ((std::rand() % 2) ? NonInlineJP(x) : NonInlineJO(x)) + 2; }
int NonInlineJR(const int x) { return ((std::rand() % 2) ? NonInlineJQ(x) : NonInlineJP(x)) + 2; }
int NonInlineJS(const int x) { return ((std::rand() % 2) ? NonInlineJR(x) : NonInlineJQ(x)) + 2; }
int NonInlineJT(const int x) { return ((std::rand() % 2) ? NonInlineJS(x) : NonInlineJR(x)) + 2; }
int NonInlineJU(const int x) { return ((std::rand() % 2) ? NonInlineJT(x) : NonInlineJS(x)) + 2; }
int NonInlineJV(const int x) { return ((std::rand() % 2) ? NonInlineJU(x) : NonInlineJT(x)) + 2; }
int NonInlineJW(const int x) { return ((std::rand() % 2) ? NonInlineJV(x) : NonInlineJU(x)) + 2; }
int NonInlineJX(const int x) { return ((std::rand() % 2) ? NonInlineJW(x) : NonInlineJV(x)) + 2; }
int NonInlineJY(const int x) { return ((std::rand() % 2) ? NonInlineJX(x) : NonInlineJW(x)) + 2; }
int NonInlineJZ(const int x) { return ((std::rand() % 2) ? NonInlineJY(x) : NonInlineJX(x)) + 2; }
int NonInlineKA(const int x) { return ((std::rand() % 2) ? NonInlineJZ(x) : NonInlineJY(x)) + 2; }
int NonInlineKB(const int x) { return ((std::rand() % 2) ? NonInlineKA(x) : NonInlineJZ(x)) + 2; }
int NonInlineKC(const int x) { return ((std::rand() % 2) ? NonInlineKB(x) : NonInlineKA(x)) + 2; }
int NonInlineKD(const int x) { return ((std::rand() % 2) ? NonInlineKC(x) : NonInlineKB(x)) + 2; }
int NonInlineKE(const int x) { return ((std::rand() % 2) ? NonInlineKD(x) : NonInlineKC(x)) + 2; }
int NonInlineKF(const int x) { return ((std::rand() % 2) ? NonInlineKE(x) : NonInlineKD(x)) + 2; }
int NonInlineKG(const int x) { return ((std::rand() % 2) ? NonInlineKF(x) : NonInlineKE(x)) + 2; }
int NonInlineKH(const int x) { return ((std::rand() % 2) ? NonInlineKG(x) : NonInlineKF(x)) + 2; }
int NonInlineKI(const int x) { return ((std::rand() % 2) ? NonInlineKH(x) : NonInlineKG(x)) + 2; }
int NonInlineKJ(const int x) { return ((std::rand() % 2) ? NonInlineKI(x) : NonInlineKH(x)) + 2; }
int NonInlineKK(const int x) { return ((std::rand() % 2) ? NonInlineKJ(x) : NonInlineKI(x)) + 2; }
int NonInlineKL(const int x) { return ((std::rand() % 2) ? NonInlineKK(x) : NonInlineKJ(x)) + 2; }
int NonInlineKM(const int x) { return ((std::rand() % 2) ? NonInlineKL(x) : NonInlineKK(x)) + 2; }
int NonInlineKN(const int x) { return ((std::rand() % 2) ? NonInlineKM(x) : NonInlineKL(x)) + 2; }
int NonInlineKO(const int x) { return ((std::rand() % 2) ? NonInlineKN(x) : NonInlineKM(x)) + 2; }
int NonInlineKP(const int x) { return ((std::rand() % 2) ? NonInlineKO(x) : NonInlineKN(x)) + 2; }
int NonInlineKQ(const int x) { return ((std::rand() % 2) ? NonInlineKP(x) : NonInlineKO(x)) + 2; }
int NonInlineKR(const int x) { return ((std::rand() % 2) ? NonInlineKQ(x) : NonInlineKP(x)) + 2; }
int NonInlineKS(const int x) { return ((std::rand() % 2) ? NonInlineKR(x) : NonInlineKQ(x)) + 2; }
int NonInlineKT(const int x) { return ((std::rand() % 2) ? NonInlineKS(x) : NonInlineKR(x)) + 2; }
int NonInlineKU(const int x) { return ((std::rand() % 2) ? NonInlineKT(x) : NonInlineKS(x)) + 2; }
int NonInlineKV(const int x) { return ((std::rand() % 2) ? NonInlineKU(x) : NonInlineKT(x)) + 2; }
int NonInlineKW(const int x) { return ((std::rand() % 2) ? NonInlineKV(x) : NonInlineKU(x)) + 2; }
int NonInlineKX(const int x) { return ((std::rand() % 2) ? NonInlineKW(x) : NonInlineKV(x)) + 2; }
int NonInlineKY(const int x) { return ((std::rand() % 2) ? NonInlineKX(x) : NonInlineKW(x)) + 2; }
int NonInlineKZ(const int x) { return ((std::rand() % 2) ? NonInlineKY(x) : NonInlineKX(x)) + 2; }
int NonInlineLA(const int x) { return ((std::rand() % 2) ? NonInlineKZ(x) : NonInlineKY(x)) + 2; }
int NonInlineLB(const int x) { return ((std::rand() % 2) ? NonInlineLA(x) : NonInlineKZ(x)) + 2; }
int NonInlineLC(const int x) { return ((std::rand() % 2) ? NonInlineLB(x) : NonInlineLA(x)) + 2; }
int NonInlineLD(const int x) { return ((std::rand() % 2) ? NonInlineLC(x) : NonInlineLB(x)) + 2; }
int NonInlineLE(const int x) { return ((std::rand() % 2) ? NonInlineLD(x) : NonInlineLC(x)) + 2; }
int NonInlineLF(const int x) { return ((std::rand() % 2) ? NonInlineLE(x) : NonInlineLD(x)) + 2; }
int NonInlineLG(const int x) { return ((std::rand() % 2) ? NonInlineLF(x) : NonInlineLE(x)) + 2; }
int NonInlineLH(const int x) { return ((std::rand() % 2) ? NonInlineLG(x) : NonInlineLF(x)) + 2; }
int NonInlineLI(const int x) { return ((std::rand() % 2) ? NonInlineLH(x) : NonInlineLG(x)) + 2; }
int NonInlineLJ(const int x) { return ((std::rand() % 2) ? NonInlineLI(x) : NonInlineLH(x)) + 2; }
int NonInlineLK(const int x) { return ((std::rand() % 2) ? NonInlineLJ(x) : NonInlineLI(x)) + 2; }
int NonInlineLL(const int x) { return ((std::rand() % 2) ? NonInlineLK(x) : NonInlineLJ(x)) + 2; }
int NonInlineLM(const int x) { return ((std::rand() % 2) ? NonInlineLL(x) : NonInlineLK(x)) + 2; }
int NonInlineLN(const int x) { return ((std::rand() % 2) ? NonInlineLM(x) : NonInlineLL(x)) + 2; }
int NonInlineLO(const int x) { return ((std::rand() % 2) ? NonInlineLN(x) : NonInlineLM(x)) + 2; }
int NonInlineLP(const int x) { return ((std::rand() % 2) ? NonInlineLO(x) : NonInlineLN(x)) + 2; }
int NonInlineLQ(const int x) { return ((std::rand() % 2) ? NonInlineLP(x) : NonInlineLO(x)) + 2; }
int NonInlineLR(const int x) { return ((std::rand() % 2) ? NonInlineLQ(x) : NonInlineLP(x)) + 2; }
int NonInlineLS(const int x) { return ((std::rand() % 2) ? NonInlineLR(x) : NonInlineLQ(x)) + 2; }
int NonInlineLT(const int x) { return ((std::rand() % 2) ? NonInlineLS(x) : NonInlineLR(x)) + 2; }
int NonInlineLU(const int x) { return ((std::rand() % 2) ? NonInlineLT(x) : NonInlineLS(x)) + 2; }
int NonInlineLV(const int x) { return ((std::rand() % 2) ? NonInlineLU(x) : NonInlineLT(x)) + 2; }
int NonInlineLW(const int x) { return ((std::rand() % 2) ? NonInlineLV(x) : NonInlineLU(x)) + 2; }
int NonInlineLX(const int x) { return ((std::rand() % 2) ? NonInlineLW(x) : NonInlineLV(x)) + 2; }
int NonInlineLY(const int x) { return ((std::rand() % 2) ? NonInlineLX(x) : NonInlineLW(x)) + 2; }
int NonInlineLZ(const int x) { return ((std::rand() % 2) ? NonInlineLY(x) : NonInlineLX(x)) + 2; }
int NonInlineMA(const int x) { return ((std::rand() % 2) ? NonInlineLZ(x) : NonInlineLY(x)) + 2; }
int NonInlineMB(const int x) { return ((std::rand() % 2) ? NonInlineMA(x) : NonInlineLZ(x)) + 2; }
int NonInlineMC(const int x) { return ((std::rand() % 2) ? NonInlineMB(x) : NonInlineMA(x)) + 2; }
int NonInlineMD(const int x) { return ((std::rand() % 2) ? NonInlineMC(x) : NonInlineMB(x)) + 2; }
int NonInlineME(const int x) { return ((std::rand() % 2) ? NonInlineMD(x) : NonInlineMC(x)) + 2; }
int NonInlineMF(const int x) { return ((std::rand() % 2) ? NonInlineME(x) : NonInlineMD(x)) + 2; }
int NonInlineMG(const int x) { return ((std::rand() % 2) ? NonInlineMF(x) : NonInlineME(x)) + 2; }
int NonInlineMH(const int x) { return ((std::rand() % 2) ? NonInlineMG(x) : NonInlineMF(x)) + 2; }
int NonInlineMI(const int x) { return ((std::rand() % 2) ? NonInlineMH(x) : NonInlineMG(x)) + 2; }
int NonInlineMJ(const int x) { return ((std::rand() % 2) ? NonInlineMI(x) : NonInlineMH(x)) + 2; }
int NonInlineMK(const int x) { return ((std::rand() % 2) ? NonInlineMJ(x) : NonInlineMI(x)) + 2; }
int NonInlineML(const int x) { return ((std::rand() % 2) ? NonInlineMK(x) : NonInlineMJ(x)) + 2; }
int NonInlineMM(const int x) { return ((std::rand() % 2) ? NonInlineML(x) : NonInlineMK(x)) + 2; }
int NonInlineMN(const int x) { return ((std::rand() % 2) ? NonInlineMM(x) : NonInlineML(x)) + 2; }
int NonInlineMO(const int x) { return ((std::rand() % 2) ? NonInlineMN(x) : NonInlineMM(x)) + 2; }
int NonInlineMP(const int x) { return ((std::rand() % 2) ? NonInlineMO(x) : NonInlineMN(x)) + 2; }
int NonInlineMQ(const int x) { return ((std::rand() % 2) ? NonInlineMP(x) : NonInlineMO(x)) + 2; }
int NonInlineMR(const int x) { return ((std::rand() % 2) ? NonInlineMQ(x) : NonInlineMP(x)) + 2; }
int NonInlineMS(const int x) { return ((std::rand() % 2) ? NonInlineMR(x) : NonInlineMQ(x)) + 2; }
int NonInlineMT(const int x) { return ((std::rand() % 2) ? NonInlineMS(x) : NonInlineMR(x)) + 2; }
int NonInlineMU(const int x) { return ((std::rand() % 2) ? NonInlineMT(x) : NonInlineMS(x)) + 2; }
int NonInlineMV(const int x) { return ((std::rand() % 2) ? NonInlineMU(x) : NonInlineMT(x)) + 2; }
int NonInlineMW(const int x) { return ((std::rand() % 2) ? NonInlineMV(x) : NonInlineMU(x)) + 2; }
int NonInlineMX(const int x) { return ((std::rand() % 2) ? NonInlineMW(x) : NonInlineMV(x)) + 2; }
int NonInlineMY(const int x) { return ((std::rand() % 2) ? NonInlineMX(x) : NonInlineMW(x)) + 2; }
int NonInlineMZ(const int x) { return ((std::rand() % 2) ? NonInlineMY(x) : NonInlineMX(x)) + 2; }
int NonInlineNA(const int x) { return ((std::rand() % 2) ? NonInlineMZ(x) : NonInlineMY(x)) + 2; }
int NonInlineNB(const int x) { return ((std::rand() % 2) ? NonInlineNA(x) : NonInlineMZ(x)) + 2; }
int NonInlineNC(const int x) { return ((std::rand() % 2) ? NonInlineNB(x) : NonInlineNA(x)) + 2; }
int NonInlineND(const int x) { return ((std::rand() % 2) ? NonInlineNC(x) : NonInlineNB(x)) + 2; }
int NonInlineNE(const int x) { return ((std::rand() % 2) ? NonInlineND(x) : NonInlineNC(x)) + 2; }
int NonInlineNF(const int x) { return ((std::rand() % 2) ? NonInlineNE(x) : NonInlineND(x)) + 2; }
int NonInlineNG(const int x) { return ((std::rand() % 2) ? NonInlineNF(x) : NonInlineNE(x)) + 2; }
int NonInlineNH(const int x) { return ((std::rand() % 2) ? NonInlineNG(x) : NonInlineNF(x)) + 2; }
int NonInlineNI(const int x) { return ((std::rand() % 2) ? NonInlineNH(x) : NonInlineNG(x)) + 2; }
int NonInlineNJ(const int x) { return ((std::rand() % 2) ? NonInlineNI(x) : NonInlineNH(x)) + 2; }
int NonInlineNK(const int x) { return ((std::rand() % 2) ? NonInlineNJ(x) : NonInlineNI(x)) + 2; }
int NonInlineNL(const int x) { return ((std::rand() % 2) ? NonInlineNK(x) : NonInlineNJ(x)) + 2; }
int NonInlineNM(const int x) { return ((std::rand() % 2) ? NonInlineNL(x) : NonInlineNK(x)) + 2; }
int NonInlineNN(const int x) { return ((std::rand() % 2) ? NonInlineNM(x) : NonInlineNL(x)) + 2; }
int NonInlineNO(const int x) { return ((std::rand() % 2) ? NonInlineNN(x) : NonInlineNM(x)) + 2; }
int NonInlineNP(const int x) { return ((std::rand() % 2) ? NonInlineNO(x) : NonInlineNN(x)) + 2; }
int NonInlineNQ(const int x) { return ((std::rand() % 2) ? NonInlineNP(x) : NonInlineNO(x)) + 2; }
int NonInlineNR(const int x) { return ((std::rand() % 2) ? NonInlineNQ(x) : NonInlineNP(x)) + 2; }
int NonInlineNS(const int x) { return ((std::rand() % 2) ? NonInlineNR(x) : NonInlineNQ(x)) + 2; }
int NonInlineNT(const int x) { return ((std::rand() % 2) ? NonInlineNS(x) : NonInlineNR(x)) + 2; }
int NonInlineNU(const int x) { return ((std::rand() % 2) ? NonInlineNT(x) : NonInlineNS(x)) + 2; }
int NonInlineNV(const int x) { return ((std::rand() % 2) ? NonInlineNU(x) : NonInlineNT(x)) + 2; }
int NonInlineNW(const int x) { return ((std::rand() % 2) ? NonInlineNV(x) : NonInlineNU(x)) + 2; }
int NonInlineNX(const int x) { return ((std::rand() % 2) ? NonInlineNW(x) : NonInlineNV(x)) + 2; }
int NonInlineNY(const int x) { return ((std::rand() % 2) ? NonInlineNX(x) : NonInlineNW(x)) + 2; }
int NonInlineNZ(const int x) { return ((std::rand() % 2) ? NonInlineNY(x) : NonInlineNX(x)) + 2; }
int NonInlineOA(const int x) { return ((std::rand() % 2) ? NonInlineNZ(x) : NonInlineNY(x)) + 2; }
int NonInlineOB(const int x) { return ((std::rand() % 2) ? NonInlineOA(x) : NonInlineNZ(x)) + 2; }
int NonInlineOC(const int x) { return ((std::rand() % 2) ? NonInlineOB(x) : NonInlineOA(x)) + 2; }
int NonInlineOD(const int x) { return ((std::rand() % 2) ? NonInlineOC(x) : NonInlineOB(x)) + 2; }
int NonInlineOE(const int x) { return ((std::rand() % 2) ? NonInlineOD(x) : NonInlineOC(x)) + 2; }
int NonInlineOF(const int x) { return ((std::rand() % 2) ? NonInlineOE(x) : NonInlineOD(x)) + 2; }
int NonInlineOG(const int x) { return ((std::rand() % 2) ? NonInlineOF(x) : NonInlineOE(x)) + 2; }
int NonInlineOH(const int x) { return ((std::rand() % 2) ? NonInlineOG(x) : NonInlineOF(x)) + 2; }
int NonInlineOI(const int x) { return ((std::rand() % 2) ? NonInlineOH(x) : NonInlineOG(x)) + 2; }
int NonInlineOJ(const int x) { return ((std::rand() % 2) ? NonInlineOI(x) : NonInlineOH(x)) + 2; }
int NonInlineOK(const int x) { return ((std::rand() % 2) ? NonInlineOJ(x) : NonInlineOI(x)) + 2; }
int NonInlineOL(const int x) { return ((std::rand() % 2) ? NonInlineOK(x) : NonInlineOJ(x)) + 2; }
int NonInlineOM(const int x) { return ((std::rand() % 2) ? NonInlineOL(x) : NonInlineOK(x)) + 2; }
int NonInlineON(const int x) { return ((std::rand() % 2) ? NonInlineOM(x) : NonInlineOL(x)) + 2; }
int NonInlineOO(const int x) { return ((std::rand() % 2) ? NonInlineON(x) : NonInlineOM(x)) + 2; }
int NonInlineOP(const int x) { return ((std::rand() % 2) ? NonInlineOO(x) : NonInlineON(x)) + 2; }
int NonInlineOQ(const int x) { return ((std::rand() % 2) ? NonInlineOP(x) : NonInlineOO(x)) + 2; }
int NonInlineOR(const int x) { return ((std::rand() % 2) ? NonInlineOQ(x) : NonInlineOP(x)) + 2; }
int NonInlineOS(const int x) { return ((std::rand() % 2) ? NonInlineOR(x) : NonInlineOQ(x)) + 2; }
int NonInlineOT(const int x) { return ((std::rand() % 2) ? NonInlineOS(x) : NonInlineOR(x)) + 2; }
int NonInlineOU(const int x) { return ((std::rand() % 2) ? NonInlineOT(x) : NonInlineOS(x)) + 2; }
int NonInlineOV(const int x) { return ((std::rand() % 2) ? NonInlineOU(x) : NonInlineOT(x)) + 2; }
int NonInlineOW(const int x) { return ((std::rand() % 2) ? NonInlineOV(x) : NonInlineOU(x)) + 2; }
int NonInlineOX(const int x) { return ((std::rand() % 2) ? NonInlineOW(x) : NonInlineOV(x)) + 2; }
int NonInlineOY(const int x) { return ((std::rand() % 2) ? NonInlineOX(x) : NonInlineOW(x)) + 2; }
int NonInlineOZ(const int x) { return ((std::rand() % 2) ? NonInlineOY(x) : NonInlineOX(x)) + 2; }
int NonInlinePA(const int x) { return ((std::rand() % 2) ? NonInlineOZ(x) : NonInlineOY(x)) + 2; }
int NonInlinePB(const int x) { return ((std::rand() % 2) ? NonInlinePA(x) : NonInlineOZ(x)) + 2; }
int NonInlinePC(const int x) { return ((std::rand() % 2) ? NonInlinePB(x) : NonInlinePA(x)) + 2; }
int NonInlinePD(const int x) { return ((std::rand() % 2) ? NonInlinePC(x) : NonInlinePB(x)) + 2; }
int NonInlinePE(const int x) { return ((std::rand() % 2) ? NonInlinePD(x) : NonInlinePC(x)) + 2; }
int NonInlinePF(const int x) { return ((std::rand() % 2) ? NonInlinePE(x) : NonInlinePD(x)) + 2; }
int NonInlinePG(const int x) { return ((std::rand() % 2) ? NonInlinePF(x) : NonInlinePE(x)) + 2; }
int NonInlinePH(const int x) { return ((std::rand() % 2) ? NonInlinePG(x) : NonInlinePF(x)) + 2; }
int NonInlinePI(const int x) { return ((std::rand() % 2) ? NonInlinePH(x) : NonInlinePG(x)) + 2; }
int NonInlinePJ(const int x) { return ((std::rand() % 2) ? NonInlinePI(x) : NonInlinePH(x)) + 2; }
int NonInlinePK(const int x) { return ((std::rand() % 2) ? NonInlinePJ(x) : NonInlinePI(x)) + 2; }
int NonInlinePL(const int x) { return ((std::rand() % 2) ? NonInlinePK(x) : NonInlinePJ(x)) + 2; }
int NonInlinePM(const int x) { return ((std::rand() % 2) ? NonInlinePL(x) : NonInlinePK(x)) + 2; }
int NonInlinePN(const int x) { return ((std::rand() % 2) ? NonInlinePM(x) : NonInlinePL(x)) + 2; }
int NonInlinePO(const int x) { return ((std::rand() % 2) ? NonInlinePN(x) : NonInlinePM(x)) + 2; }
int NonInlinePP(const int x) { return ((std::rand() % 2) ? NonInlinePO(x) : NonInlinePN(x)) + 2; }
int NonInlinePQ(const int x) { return ((std::rand() % 2) ? NonInlinePP(x) : NonInlinePO(x)) + 2; }
int NonInlinePR(const int x) { return ((std::rand() % 2) ? NonInlinePQ(x) : NonInlinePP(x)) + 2; }
int NonInlinePS(const int x) { return ((std::rand() % 2) ? NonInlinePR(x) : NonInlinePQ(x)) + 2; }
int NonInlinePT(const int x) { return ((std::rand() % 2) ? NonInlinePS(x) : NonInlinePR(x)) + 2; }
int NonInlinePU(const int x) { return ((std::rand() % 2) ? NonInlinePT(x) : NonInlinePS(x)) + 2; }
int NonInlinePV(const int x) { return ((std::rand() % 2) ? NonInlinePU(x) : NonInlinePT(x)) + 2; }
int NonInlinePW(const int x) { return ((std::rand() % 2) ? NonInlinePV(x) : NonInlinePU(x)) + 2; }
int NonInlinePX(const int x) { return ((std::rand() % 2) ? NonInlinePW(x) : NonInlinePV(x)) + 2; }
int NonInlinePY(const int x) { return ((std::rand() % 2) ? NonInlinePX(x) : NonInlinePW(x)) + 2; }
int NonInlinePZ(const int x) { return ((std::rand() % 2) ? NonInlinePY(x) : NonInlinePX(x)) + 2; }
int NonInlineQA(const int x) { return ((std::rand() % 2) ? NonInlinePZ(x) : NonInlinePY(x)) + 2; }
int NonInlineQB(const int x) { return ((std::rand() % 2) ? NonInlineQA(x) : NonInlinePZ(x)) + 2; }
int NonInlineQC(const int x) { return ((std::rand() % 2) ? NonInlineQB(x) : NonInlineQA(x)) + 2; }
int NonInlineQD(const int x) { return ((std::rand() % 2) ? NonInlineQC(x) : NonInlineQB(x)) + 2; }
int NonInlineQE(const int x) { return ((std::rand() % 2) ? NonInlineQD(x) : NonInlineQC(x)) + 2; }
int NonInlineQF(const int x) { return ((std::rand() % 2) ? NonInlineQE(x) : NonInlineQD(x)) + 2; }
int NonInlineQG(const int x) { return ((std::rand() % 2) ? NonInlineQF(x) : NonInlineQE(x)) + 2; }
int NonInlineQH(const int x) { return ((std::rand() % 2) ? NonInlineQG(x) : NonInlineQF(x)) + 2; }
int NonInlineQI(const int x) { return ((std::rand() % 2) ? NonInlineQH(x) : NonInlineQG(x)) + 2; }
int NonInlineQJ(const int x) { return ((std::rand() % 2) ? NonInlineQI(x) : NonInlineQH(x)) + 2; }
int NonInlineQK(const int x) { return ((std::rand() % 2) ? NonInlineQJ(x) : NonInlineQI(x)) + 2; }
int NonInlineQL(const int x) { return ((std::rand() % 2) ? NonInlineQK(x) : NonInlineQJ(x)) + 2; }
int NonInlineQM(const int x) { return ((std::rand() % 2) ? NonInlineQL(x) : NonInlineQK(x)) + 2; }
int NonInlineQN(const int x) { return ((std::rand() % 2) ? NonInlineQM(x) : NonInlineQL(x)) + 2; }
int NonInlineQO(const int x) { return ((std::rand() % 2) ? NonInlineQN(x) : NonInlineQM(x)) + 2; }
int NonInlineQP(const int x) { return ((std::rand() % 2) ? NonInlineQO(x) : NonInlineQN(x)) + 2; }
int NonInlineQQ(const int x) { return ((std::rand() % 2) ? NonInlineQP(x) : NonInlineQO(x)) + 2; }
int NonInlineQR(const int x) { return ((std::rand() % 2) ? NonInlineQQ(x) : NonInlineQP(x)) + 2; }
int NonInlineQS(const int x) { return ((std::rand() % 2) ? NonInlineQR(x) : NonInlineQQ(x)) + 2; }
int NonInlineQT(const int x) { return ((std::rand() % 2) ? NonInlineQS(x) : NonInlineQR(x)) + 2; }
int NonInlineQU(const int x) { return ((std::rand() % 2) ? NonInlineQT(x) : NonInlineQS(x)) + 2; }
int NonInlineQV(const int x) { return ((std::rand() % 2) ? NonInlineQU(x) : NonInlineQT(x)) + 2; }
int NonInlineQW(const int x) { return ((std::rand() % 2) ? NonInlineQV(x) : NonInlineQU(x)) + 2; }
int NonInlineQX(const int x) { return ((std::rand() % 2) ? NonInlineQW(x) : NonInlineQV(x)) + 2; }
int NonInlineQY(const int x) { return ((std::rand() % 2) ? NonInlineQX(x) : NonInlineQW(x)) + 2; }
int NonInlineQZ(const int x) { return ((std::rand() % 2) ? NonInlineQY(x) : NonInlineQX(x)) + 2; }
int NonInlineRA(const int x) { return ((std::rand() % 2) ? NonInlineQZ(x) : NonInlineQY(x)) + 2; }
int NonInlineRB(const int x) { return ((std::rand() % 2) ? NonInlineRA(x) : NonInlineQZ(x)) + 2; }
int NonInlineRC(const int x) { return ((std::rand() % 2) ? NonInlineRB(x) : NonInlineRA(x)) + 2; }
int NonInlineRD(const int x) { return ((std::rand() % 2) ? NonInlineRC(x) : NonInlineRB(x)) + 2; }
int NonInlineRE(const int x) { return ((std::rand() % 2) ? NonInlineRD(x) : NonInlineRC(x)) + 2; }
int NonInlineRF(const int x) { return ((std::rand() % 2) ? NonInlineRE(x) : NonInlineRD(x)) + 2; }
int NonInlineRG(const int x) { return ((std::rand() % 2) ? NonInlineRF(x) : NonInlineRE(x)) + 2; }
int NonInlineRH(const int x) { return ((std::rand() % 2) ? NonInlineRG(x) : NonInlineRF(x)) + 2; }
int NonInlineRI(const int x) { return ((std::rand() % 2) ? NonInlineRH(x) : NonInlineRG(x)) + 2; }
int NonInlineRJ(const int x) { return ((std::rand() % 2) ? NonInlineRI(x) : NonInlineRH(x)) + 2; }
int NonInlineRK(const int x) { return ((std::rand() % 2) ? NonInlineRJ(x) : NonInlineRI(x)) + 2; }
int NonInlineRL(const int x) { return ((std::rand() % 2) ? NonInlineRK(x) : NonInlineRJ(x)) + 2; }
int NonInlineRM(const int x) { return ((std::rand() % 2) ? NonInlineRL(x) : NonInlineRK(x)) + 2; }
int NonInlineRN(const int x) { return ((std::rand() % 2) ? NonInlineRM(x) : NonInlineRL(x)) + 2; }
int NonInlineRO(const int x) { return ((std::rand() % 2) ? NonInlineRN(x) : NonInlineRM(x)) + 2; }
int NonInlineRP(const int x) { return ((std::rand() % 2) ? NonInlineRO(x) : NonInlineRN(x)) + 2; }
int NonInlineRQ(const int x) { return ((std::rand() % 2) ? NonInlineRP(x) : NonInlineRO(x)) + 2; }
int NonInlineRR(const int x) { return ((std::rand() % 2) ? NonInlineRQ(x) : NonInlineRP(x)) + 2; }
int NonInlineRS(const int x) { return ((std::rand() % 2) ? NonInlineRR(x) : NonInlineRQ(x)) + 2; }
int NonInlineRT(const int x) { return ((std::rand() % 2) ? NonInlineRS(x) : NonInlineRR(x)) + 2; }
int NonInlineRU(const int x) { return ((std::rand() % 2) ? NonInlineRT(x) : NonInlineRS(x)) + 2; }
int NonInlineRV(const int x) { return ((std::rand() % 2) ? NonInlineRU(x) : NonInlineRT(x)) + 2; }
int NonInlineRW(const int x) { return ((std::rand() % 2) ? NonInlineRV(x) : NonInlineRU(x)) + 2; }
int NonInlineRX(const int x) { return ((std::rand() % 2) ? NonInlineRW(x) : NonInlineRV(x)) + 2; }
int NonInlineRY(const int x) { return ((std::rand() % 2) ? NonInlineRX(x) : NonInlineRW(x)) + 2; }
int NonInlineRZ(const int x) { return ((std::rand() % 2) ? NonInlineRY(x) : NonInlineRX(x)) + 2; }
int NonInlineSA(const int x) { return ((std::rand() % 2) ? NonInlineRZ(x) : NonInlineRY(x)) + 2; }
int NonInlineSB(const int x) { return ((std::rand() % 2) ? NonInlineSA(x) : NonInlineRZ(x)) + 2; }
int NonInlineSC(const int x) { return ((std::rand() % 2) ? NonInlineSB(x) : NonInlineSA(x)) + 2; }
int NonInlineSD(const int x) { return ((std::rand() % 2) ? NonInlineSC(x) : NonInlineSB(x)) + 2; }
int NonInlineSE(const int x) { return ((std::rand() % 2) ? NonInlineSD(x) : NonInlineSC(x)) + 2; }
int NonInlineSF(const int x) { return ((std::rand() % 2) ? NonInlineSE(x) : NonInlineSD(x)) + 2; }
int NonInlineSG(const int x) { return ((std::rand() % 2) ? NonInlineSF(x) : NonInlineSE(x)) + 2; }
int NonInlineSH(const int x) { return ((std::rand() % 2) ? NonInlineSG(x) : NonInlineSF(x)) + 2; }
int NonInlineSI(const int x) { return ((std::rand() % 2) ? NonInlineSH(x) : NonInlineSG(x)) + 2; }
int NonInlineSJ(const int x) { return ((std::rand() % 2) ? NonInlineSI(x) : NonInlineSH(x)) + 2; }
int NonInlineSK(const int x) { return ((std::rand() % 2) ? NonInlineSJ(x) : NonInlineSI(x)) + 2; }
int NonInlineSL(const int x) { return ((std::rand() % 2) ? NonInlineSK(x) : NonInlineSJ(x)) + 2; }
int NonInlineSM(const int x) { return ((std::rand() % 2) ? NonInlineSL(x) : NonInlineSK(x)) + 2; }
int NonInlineSN(const int x) { return ((std::rand() % 2) ? NonInlineSM(x) : NonInlineSL(x)) + 2; }
int NonInlineSO(const int x) { return ((std::rand() % 2) ? NonInlineSN(x) : NonInlineSM(x)) + 2; }
int NonInlineSP(const int x) { return ((std::rand() % 2) ? NonInlineSO(x) : NonInlineSN(x)) + 2; }
int NonInlineSQ(const int x) { return ((std::rand() % 2) ? NonInlineSP(x) : NonInlineSO(x)) + 2; }
int NonInlineSR(const int x) { return ((std::rand() % 2) ? NonInlineSQ(x) : NonInlineSP(x)) + 2; }
int NonInlineSS(const int x) { return ((std::rand() % 2) ? NonInlineSR(x) : NonInlineSQ(x)) + 2; }
int NonInlineST(const int x) { return ((std::rand() % 2) ? NonInlineSS(x) : NonInlineSR(x)) + 2; }
int NonInlineSU(const int x) { return ((std::rand() % 2) ? NonInlineST(x) : NonInlineSS(x)) + 2; }
int NonInlineSV(const int x) { return ((std::rand() % 2) ? NonInlineSU(x) : NonInlineST(x)) + 2; }
int NonInlineSW(const int x) { return ((std::rand() % 2) ? NonInlineSV(x) : NonInlineSU(x)) + 2; }
int NonInlineSX(const int x) { return ((std::rand() % 2) ? NonInlineSW(x) : NonInlineSV(x)) + 2; }
int NonInlineSY(const int x) { return ((std::rand() % 2) ? NonInlineSX(x) : NonInlineSW(x)) + 2; }
int NonInlineSZ(const int x) { return ((std::rand() % 2) ? NonInlineSY(x) : NonInlineSX(x)) + 2; }
int NonInlineTA(const int x) { return ((std::rand() % 2) ? NonInlineSZ(x) : NonInlineSY(x)) + 2; }
int NonInlineTB(const int x) { return ((std::rand() % 2) ? NonInlineTA(x) : NonInlineSZ(x)) + 2; }
int NonInlineTC(const int x) { return ((std::rand() % 2) ? NonInlineTB(x) : NonInlineTA(x)) + 2; }
int NonInlineTD(const int x) { return ((std::rand() % 2) ? NonInlineTC(x) : NonInlineTB(x)) + 2; }
int NonInlineTE(const int x) { return ((std::rand() % 2) ? NonInlineTD(x) : NonInlineTC(x)) + 2; }
int NonInlineTF(const int x) { return ((std::rand() % 2) ? NonInlineTE(x) : NonInlineTD(x)) + 2; }
int NonInlineTG(const int x) { return ((std::rand() % 2) ? NonInlineTF(x) : NonInlineTE(x)) + 2; }
int NonInlineTH(const int x) { return ((std::rand() % 2) ? NonInlineTG(x) : NonInlineTF(x)) + 2; }
int NonInlineTI(const int x) { return ((std::rand() % 2) ? NonInlineTH(x) : NonInlineTG(x)) + 2; }
int NonInlineTJ(const int x) { return ((std::rand() % 2) ? NonInlineTI(x) : NonInlineTH(x)) + 2; }
int NonInlineTK(const int x) { return ((std::rand() % 2) ? NonInlineTJ(x) : NonInlineTI(x)) + 2; }
int NonInlineTL(const int x) { return ((std::rand() % 2) ? NonInlineTK(x) : NonInlineTJ(x)) + 2; }
int NonInlineTM(const int x) { return ((std::rand() % 2) ? NonInlineTL(x) : NonInlineTK(x)) + 2; }
int NonInlineTN(const int x) { return ((std::rand() % 2) ? NonInlineTM(x) : NonInlineTL(x)) + 2; }
int NonInlineTO(const int x) { return ((std::rand() % 2) ? NonInlineTN(x) : NonInlineTM(x)) + 2; }
int NonInlineTP(const int x) { return ((std::rand() % 2) ? NonInlineTO(x) : NonInlineTN(x)) + 2; }
int NonInlineTQ(const int x) { return ((std::rand() % 2) ? NonInlineTP(x) : NonInlineTO(x)) + 2; }
int NonInlineTR(const int x) { return ((std::rand() % 2) ? NonInlineTQ(x) : NonInlineTP(x)) + 2; }
int NonInlineTS(const int x) { return ((std::rand() % 2) ? NonInlineTR(x) : NonInlineTQ(x)) + 2; }
int NonInlineTT(const int x) { return ((std::rand() % 2) ? NonInlineTS(x) : NonInlineTR(x)) + 2; }
int NonInlineTU(const int x) { return ((std::rand() % 2) ? NonInlineTT(x) : NonInlineTS(x)) + 2; }
int NonInlineTV(const int x) { return ((std::rand() % 2) ? NonInlineTU(x) : NonInlineTT(x)) + 2; }
int NonInlineTW(const int x) { return ((std::rand() % 2) ? NonInlineTV(x) : NonInlineTU(x)) + 2; }
int NonInlineTX(const int x) { return ((std::rand() % 2) ? NonInlineTW(x) : NonInlineTV(x)) + 2; }
int NonInlineTY(const int x) { return ((std::rand() % 2) ? NonInlineTX(x) : NonInlineTW(x)) + 2; }
int NonInlineTZ(const int x) { return ((std::rand() % 2) ? NonInlineTY(x) : NonInlineTX(x)) + 2; }
int NonInlineUA(const int x) { return ((std::rand() % 2) ? NonInlineTZ(x) : NonInlineTY(x)) + 2; }
int NonInlineUB(const int x) { return ((std::rand() % 2) ? NonInlineUA(x) : NonInlineTZ(x)) + 2; }
int NonInlineUC(const int x) { return ((std::rand() % 2) ? NonInlineUB(x) : NonInlineUA(x)) + 2; }
int NonInlineUD(const int x) { return ((std::rand() % 2) ? NonInlineUC(x) : NonInlineUB(x)) + 2; }
int NonInlineUE(const int x) { return ((std::rand() % 2) ? NonInlineUD(x) : NonInlineUC(x)) + 2; }
int NonInlineUF(const int x) { return ((std::rand() % 2) ? NonInlineUE(x) : NonInlineUD(x)) + 2; }
int NonInlineUG(const int x) { return ((std::rand() % 2) ? NonInlineUF(x) : NonInlineUE(x)) + 2; }
int NonInlineUH(const int x) { return ((std::rand() % 2) ? NonInlineUG(x) : NonInlineUF(x)) + 2; }
int NonInlineUI(const int x) { return ((std::rand() % 2) ? NonInlineUH(x) : NonInlineUG(x)) + 2; }
int NonInlineUJ(const int x) { return ((std::rand() % 2) ? NonInlineUI(x) : NonInlineUH(x)) + 2; }
int NonInlineUK(const int x) { return ((std::rand() % 2) ? NonInlineUJ(x) : NonInlineUI(x)) + 2; }
int NonInlineUL(const int x) { return ((std::rand() % 2) ? NonInlineUK(x) : NonInlineUJ(x)) + 2; }
int NonInlineUM(const int x) { return ((std::rand() % 2) ? NonInlineUL(x) : NonInlineUK(x)) + 2; }
int NonInlineUN(const int x) { return ((std::rand() % 2) ? NonInlineUM(x) : NonInlineUL(x)) + 2; }
int NonInlineUO(const int x) { return ((std::rand() % 2) ? NonInlineUN(x) : NonInlineUM(x)) + 2; }
int NonInlineUP(const int x) { return ((std::rand() % 2) ? NonInlineUO(x) : NonInlineUN(x)) + 2; }
int NonInlineUQ(const int x) { return ((std::rand() % 2) ? NonInlineUP(x) : NonInlineUO(x)) + 2; }
int NonInlineUR(const int x) { return ((std::rand() % 2) ? NonInlineUQ(x) : NonInlineUP(x)) + 2; }
int NonInlineUS(const int x) { return ((std::rand() % 2) ? NonInlineUR(x) : NonInlineUQ(x)) + 2; }
int NonInlineUT(const int x) { return ((std::rand() % 2) ? NonInlineUS(x) : NonInlineUR(x)) + 2; }
int NonInlineUU(const int x) { return ((std::rand() % 2) ? NonInlineUT(x) : NonInlineUS(x)) + 2; }
int NonInlineUV(const int x) { return ((std::rand() % 2) ? NonInlineUU(x) : NonInlineUT(x)) + 2; }
int NonInlineUW(const int x) { return ((std::rand() % 2) ? NonInlineUV(x) : NonInlineUU(x)) + 2; }
int NonInlineUX(const int x) { return ((std::rand() % 2) ? NonInlineUW(x) : NonInlineUV(x)) + 2; }
int NonInlineUY(const int x) { return ((std::rand() % 2) ? NonInlineUX(x) : NonInlineUW(x)) + 2; }
int NonInlineUZ(const int x) { return ((std::rand() % 2) ? NonInlineUY(x) : NonInlineUX(x)) + 2; }
int NonInlineVA(const int x) { return ((std::rand() % 2) ? NonInlineUZ(x) : NonInlineUY(x)) + 2; }
int NonInlineVB(const int x) { return ((std::rand() % 2) ? NonInlineVA(x) : NonInlineUZ(x)) + 2; }
int NonInlineVC(const int x) { return ((std::rand() % 2) ? NonInlineVB(x) : NonInlineVA(x)) + 2; }
int NonInlineVD(const int x) { return ((std::rand() % 2) ? NonInlineVC(x) : NonInlineVB(x)) + 2; }
int NonInlineVE(const int x) { return ((std::rand() % 2) ? NonInlineVD(x) : NonInlineVC(x)) + 2; }
int NonInlineVF(const int x) { return ((std::rand() % 2) ? NonInlineVE(x) : NonInlineVD(x)) + 2; }
int NonInlineVG(const int x) { return ((std::rand() % 2) ? NonInlineVF(x) : NonInlineVE(x)) + 2; }
int NonInlineVH(const int x) { return ((std::rand() % 2) ? NonInlineVG(x) : NonInlineVF(x)) + 2; }
int NonInlineVI(const int x) { return ((std::rand() % 2) ? NonInlineVH(x) : NonInlineVG(x)) + 2; }
int NonInlineVJ(const int x) { return ((std::rand() % 2) ? NonInlineVI(x) : NonInlineVH(x)) + 2; }
int NonInlineVK(const int x) { return ((std::rand() % 2) ? NonInlineVJ(x) : NonInlineVI(x)) + 2; }
int NonInlineVL(const int x) { return ((std::rand() % 2) ? NonInlineVK(x) : NonInlineVJ(x)) + 2; }
int NonInlineVM(const int x) { return ((std::rand() % 2) ? NonInlineVL(x) : NonInlineVK(x)) + 2; }
int NonInlineVN(const int x) { return ((std::rand() % 2) ? NonInlineVM(x) : NonInlineVL(x)) + 2; }
int NonInlineVO(const int x) { return ((std::rand() % 2) ? NonInlineVN(x) : NonInlineVM(x)) + 2; }
int NonInlineVP(const int x) { return ((std::rand() % 2) ? NonInlineVO(x) : NonInlineVN(x)) + 2; }
int NonInlineVQ(const int x) { return ((std::rand() % 2) ? NonInlineVP(x) : NonInlineVO(x)) + 2; }
int NonInlineVR(const int x) { return ((std::rand() % 2) ? NonInlineVQ(x) : NonInlineVP(x)) + 2; }
int NonInlineVS(const int x) { return ((std::rand() % 2) ? NonInlineVR(x) : NonInlineVQ(x)) + 2; }
int NonInlineVT(const int x) { return ((std::rand() % 2) ? NonInlineVS(x) : NonInlineVR(x)) + 2; }
int NonInlineVU(const int x) { return ((std::rand() % 2) ? NonInlineVT(x) : NonInlineVS(x)) + 2; }
int NonInlineVV(const int x) { return ((std::rand() % 2) ? NonInlineVU(x) : NonInlineVT(x)) + 2; }
int NonInlineVW(const int x) { return ((std::rand() % 2) ? NonInlineVV(x) : NonInlineVU(x)) + 2; }
int NonInlineVX(const int x) { return ((std::rand() % 2) ? NonInlineVW(x) : NonInlineVV(x)) + 2; }
int NonInlineVY(const int x) { return ((std::rand() % 2) ? NonInlineVX(x) : NonInlineVW(x)) + 2; }
int NonInlineVZ(const int x) { return ((std::rand() % 2) ? NonInlineVY(x) : NonInlineVX(x)) + 2; }
int NonInlineWA(const int x) { return ((std::rand() % 2) ? NonInlineVZ(x) : NonInlineVY(x)) + 2; }
int NonInlineWB(const int x) { return ((std::rand() % 2) ? NonInlineWA(x) : NonInlineVZ(x)) + 2; }
int NonInlineWC(const int x) { return ((std::rand() % 2) ? NonInlineWB(x) : NonInlineWA(x)) + 2; }
int NonInlineWD(const int x) { return ((std::rand() % 2) ? NonInlineWC(x) : NonInlineWB(x)) + 2; }
int NonInlineWE(const int x) { return ((std::rand() % 2) ? NonInlineWD(x) : NonInlineWC(x)) + 2; }
int NonInlineWF(const int x) { return ((std::rand() % 2) ? NonInlineWE(x) : NonInlineWD(x)) + 2; }
int NonInlineWG(const int x) { return ((std::rand() % 2) ? NonInlineWF(x) : NonInlineWE(x)) + 2; }
int NonInlineWH(const int x) { return ((std::rand() % 2) ? NonInlineWG(x) : NonInlineWF(x)) + 2; }
int NonInlineWI(const int x) { return ((std::rand() % 2) ? NonInlineWH(x) : NonInlineWG(x)) + 2; }
int NonInlineWJ(const int x) { return ((std::rand() % 2) ? NonInlineWI(x) : NonInlineWH(x)) + 2; }
int NonInlineWK(const int x) { return ((std::rand() % 2) ? NonInlineWJ(x) : NonInlineWI(x)) + 2; }
int NonInlineWL(const int x) { return ((std::rand() % 2) ? NonInlineWK(x) : NonInlineWJ(x)) + 2; }
int NonInlineWM(const int x) { return ((std::rand() % 2) ? NonInlineWL(x) : NonInlineWK(x)) + 2; }
int NonInlineWN(const int x) { return ((std::rand() % 2) ? NonInlineWM(x) : NonInlineWL(x)) + 2; }
int NonInlineWO(const int x) { return ((std::rand() % 2) ? NonInlineWN(x) : NonInlineWM(x)) + 2; }
int NonInlineWP(const int x) { return ((std::rand() % 2) ? NonInlineWO(x) : NonInlineWN(x)) + 2; }
int NonInlineWQ(const int x) { return ((std::rand() % 2) ? NonInlineWP(x) : NonInlineWO(x)) + 2; }
int NonInlineWR(const int x) { return ((std::rand() % 2) ? NonInlineWQ(x) : NonInlineWP(x)) + 2; }
int NonInlineWS(const int x) { return ((std::rand() % 2) ? NonInlineWR(x) : NonInlineWQ(x)) + 2; }
int NonInlineWT(const int x) { return ((std::rand() % 2) ? NonInlineWS(x) : NonInlineWR(x)) + 2; }
int NonInlineWU(const int x) { return ((std::rand() % 2) ? NonInlineWT(x) : NonInlineWS(x)) + 2; }
int NonInlineWV(const int x) { return ((std::rand() % 2) ? NonInlineWU(x) : NonInlineWT(x)) + 2; }
int NonInlineWW(const int x) { return ((std::rand() % 2) ? NonInlineWV(x) : NonInlineWU(x)) + 2; }
int NonInlineWX(const int x) { return ((std::rand() % 2) ? NonInlineWW(x) : NonInlineWV(x)) + 2; }
int NonInlineWY(const int x) { return ((std::rand() % 2) ? NonInlineWX(x) : NonInlineWW(x)) + 2; }
int NonInlineWZ(const int x) { return ((std::rand() % 2) ? NonInlineWY(x) : NonInlineWX(x)) + 2; }
int NonInlineXA(const int x) { return ((std::rand() % 2) ? NonInlineWZ(x) : NonInlineWY(x)) + 2; }
int NonInlineXB(const int x) { return ((std::rand() % 2) ? NonInlineXA(x) : NonInlineWZ(x)) + 2; }
int NonInlineXC(const int x) { return ((std::rand() % 2) ? NonInlineXB(x) : NonInlineXA(x)) + 2; }
int NonInlineXD(const int x) { return ((std::rand() % 2) ? NonInlineXC(x) : NonInlineXB(x)) + 2; }
int NonInlineXE(const int x) { return ((std::rand() % 2) ? NonInlineXD(x) : NonInlineXC(x)) + 2; }
int NonInlineXF(const int x) { return ((std::rand() % 2) ? NonInlineXE(x) : NonInlineXD(x)) + 2; }
int NonInlineXG(const int x) { return ((std::rand() % 2) ? NonInlineXF(x) : NonInlineXE(x)) + 2; }
int NonInlineXH(const int x) { return ((std::rand() % 2) ? NonInlineXG(x) : NonInlineXF(x)) + 2; }
int NonInlineXI(const int x) { return ((std::rand() % 2) ? NonInlineXH(x) : NonInlineXG(x)) + 2; }
int NonInlineXJ(const int x) { return ((std::rand() % 2) ? NonInlineXI(x) : NonInlineXH(x)) + 2; }
int NonInlineXK(const int x) { return ((std::rand() % 2) ? NonInlineXJ(x) : NonInlineXI(x)) + 2; }
int NonInlineXL(const int x) { return ((std::rand() % 2) ? NonInlineXK(x) : NonInlineXJ(x)) + 2; }
int NonInlineXM(const int x) { return ((std::rand() % 2) ? NonInlineXL(x) : NonInlineXK(x)) + 2; }
int NonInlineXN(const int x) { return ((std::rand() % 2) ? NonInlineXM(x) : NonInlineXL(x)) + 2; }
int NonInlineXO(const int x) { return ((std::rand() % 2) ? NonInlineXN(x) : NonInlineXM(x)) + 2; }
int NonInlineXP(const int x) { return ((std::rand() % 2) ? NonInlineXO(x) : NonInlineXN(x)) + 2; }
int NonInlineXQ(const int x) { return ((std::rand() % 2) ? NonInlineXP(x) : NonInlineXO(x)) + 2; }
int NonInlineXR(const int x) { return ((std::rand() % 2) ? NonInlineXQ(x) : NonInlineXP(x)) + 2; }
int NonInlineXS(const int x) { return ((std::rand() % 2) ? NonInlineXR(x) : NonInlineXQ(x)) + 2; }
int NonInlineXT(const int x) { return ((std::rand() % 2) ? NonInlineXS(x) : NonInlineXR(x)) + 2; }
int NonInlineXU(const int x) { return ((std::rand() % 2) ? NonInlineXT(x) : NonInlineXS(x)) + 2; }
int NonInlineXV(const int x) { return ((std::rand() % 2) ? NonInlineXU(x) : NonInlineXT(x)) + 2; }
int NonInlineXW(const int x) { return ((std::rand() % 2) ? NonInlineXV(x) : NonInlineXU(x)) + 2; }
int NonInlineXX(const int x) { return ((std::rand() % 2) ? NonInlineXW(x) : NonInlineXV(x)) + 2; }
int NonInlineXY(const int x) { return ((std::rand() % 2) ? NonInlineXX(x) : NonInlineXW(x)) + 2; }
int NonInlineXZ(const int x) { return ((std::rand() % 2) ? NonInlineXY(x) : NonInlineXX(x)) + 2; }
int NonInlineYA(const int x) { return ((std::rand() % 2) ? NonInlineXZ(x) : NonInlineXY(x)) + 2; }
int NonInlineYB(const int x) { return ((std::rand() % 2) ? NonInlineYA(x) : NonInlineXZ(x)) + 2; }
int NonInlineYC(const int x) { return ((std::rand() % 2) ? NonInlineYB(x) : NonInlineYA(x)) + 2; }
int NonInlineYD(const int x) { return ((std::rand() % 2) ? NonInlineYC(x) : NonInlineYB(x)) + 2; }
int NonInlineYE(const int x) { return ((std::rand() % 2) ? NonInlineYD(x) : NonInlineYC(x)) + 2; }
int NonInlineYF(const int x) { return ((std::rand() % 2) ? NonInlineYE(x) : NonInlineYD(x)) + 2; }
int NonInlineYG(const int x) { return ((std::rand() % 2) ? NonInlineYF(x) : NonInlineYE(x)) + 2; }
int NonInlineYH(const int x) { return ((std::rand() % 2) ? NonInlineYG(x) : NonInlineYF(x)) + 2; }
int NonInlineYI(const int x) { return ((std::rand() % 2) ? NonInlineYH(x) : NonInlineYG(x)) + 2; }
int NonInlineYJ(const int x) { return ((std::rand() % 2) ? NonInlineYI(x) : NonInlineYH(x)) + 2; }
int NonInlineYK(const int x) { return ((std::rand() % 2) ? NonInlineYJ(x) : NonInlineYI(x)) + 2; }
int NonInlineYL(const int x) { return ((std::rand() % 2) ? NonInlineYK(x) : NonInlineYJ(x)) + 2; }
int NonInlineYM(const int x) { return ((std::rand() % 2) ? NonInlineYL(x) : NonInlineYK(x)) + 2; }
int NonInlineYN(const int x) { return ((std::rand() % 2) ? NonInlineYM(x) : NonInlineYL(x)) + 2; }
int NonInlineYO(const int x) { return ((std::rand() % 2) ? NonInlineYN(x) : NonInlineYM(x)) + 2; }
int NonInlineYP(const int x) { return ((std::rand() % 2) ? NonInlineYO(x) : NonInlineYN(x)) + 2; }
int NonInlineYQ(const int x) { return ((std::rand() % 2) ? NonInlineYP(x) : NonInlineYO(x)) + 2; }
int NonInlineYR(const int x) { return ((std::rand() % 2) ? NonInlineYQ(x) : NonInlineYP(x)) + 2; }
int NonInlineYS(const int x) { return ((std::rand() % 2) ? NonInlineYR(x) : NonInlineYQ(x)) + 2; }
int NonInlineYT(const int x) { return ((std::rand() % 2) ? NonInlineYS(x) : NonInlineYR(x)) + 2; }
int NonInlineYU(const int x) { return ((std::rand() % 2) ? NonInlineYT(x) : NonInlineYS(x)) + 2; }
int NonInlineYV(const int x) { return ((std::rand() % 2) ? NonInlineYU(x) : NonInlineYT(x)) + 2; }
int NonInlineYW(const int x) { return ((std::rand() % 2) ? NonInlineYV(x) : NonInlineYU(x)) + 2; }
int NonInlineYX(const int x) { return ((std::rand() % 2) ? NonInlineYW(x) : NonInlineYV(x)) + 2; }
int NonInlineYY(const int x) { return ((std::rand() % 2) ? NonInlineYX(x) : NonInlineYW(x)) + 2; }
int NonInlineYZ(const int x) { return ((std::rand() % 2) ? NonInlineYY(x) : NonInlineYX(x)) + 2; }
int NonInlineZA(const int x) { return ((std::rand() % 2) ? NonInlineYZ(x) : NonInlineYY(x)) + 2; }
int NonInlineZB(const int x) { return ((std::rand() % 2) ? NonInlineZA(x) : NonInlineYZ(x)) + 2; }
int NonInlineZC(const int x) { return ((std::rand() % 2) ? NonInlineZB(x) : NonInlineZA(x)) + 2; }
int NonInlineZD(const int x) { return ((std::rand() % 2) ? NonInlineZC(x) : NonInlineZB(x)) + 2; }
int NonInlineZE(const int x) { return ((std::rand() % 2) ? NonInlineZD(x) : NonInlineZC(x)) + 2; }
int NonInlineZF(const int x) { return ((std::rand() % 2) ? NonInlineZE(x) : NonInlineZD(x)) + 2; }
int NonInlineZG(const int x) { return ((std::rand() % 2) ? NonInlineZF(x) : NonInlineZE(x)) + 2; }
int NonInlineZH(const int x) { return ((std::rand() % 2) ? NonInlineZG(x) : NonInlineZF(x)) + 2; }
int NonInlineZI(const int x) { return ((std::rand() % 2) ? NonInlineZH(x) : NonInlineZG(x)) + 2; }
int NonInlineZJ(const int x) { return ((std::rand() % 2) ? NonInlineZI(x) : NonInlineZH(x)) + 2; }
int NonInlineZK(const int x) { return ((std::rand() % 2) ? NonInlineZJ(x) : NonInlineZI(x)) + 2; }
int NonInlineZL(const int x) { return ((std::rand() % 2) ? NonInlineZK(x) : NonInlineZJ(x)) + 2; }
int NonInlineZM(const int x) { return ((std::rand() % 2) ? NonInlineZL(x) : NonInlineZK(x)) + 2; }
int NonInlineZN(const int x) { return ((std::rand() % 2) ? NonInlineZM(x) : NonInlineZL(x)) + 2; }
int NonInlineZO(const int x) { return ((std::rand() % 2) ? NonInlineZN(x) : NonInlineZM(x)) + 2; }
int NonInlineZP(const int x) { return ((std::rand() % 2) ? NonInlineZO(x) : NonInlineZN(x)) + 2; }
int NonInlineZQ(const int x) { return ((std::rand() % 2) ? NonInlineZP(x) : NonInlineZO(x)) + 2; }
int NonInlineZR(const int x) { return ((std::rand() % 2) ? NonInlineZQ(x) : NonInlineZP(x)) + 2; }
int NonInlineZS(const int x) { return ((std::rand() % 2) ? NonInlineZR(x) : NonInlineZQ(x)) + 2; }
int NonInlineZT(const int x) { return ((std::rand() % 2) ? NonInlineZS(x) : NonInlineZR(x)) + 2; }
int NonInlineZU(const int x) { return ((std::rand() % 2) ? NonInlineZT(x) : NonInlineZS(x)) + 2; }
int NonInlineZV(const int x) { return ((std::rand() % 2) ? NonInlineZU(x) : NonInlineZT(x)) + 2; }
int NonInlineZW(const int x) { return ((std::rand() % 2) ? NonInlineZV(x) : NonInlineZU(x)) + 2; }
int NonInlineZX(const int x) { return ((std::rand() % 2) ? NonInlineZW(x) : NonInlineZV(x)) + 2; }
int NonInlineZY(const int x) { return ((std::rand() % 2) ? NonInlineZX(x) : NonInlineZW(x)) + 2; }
int NonInlineZZ(const int x) { return ((std::rand() % 2) ? NonInlineZY(x) : NonInlineZX(x)) + 2; }

#include <string>

struct Function
{
  typedef int (*FunctionPointer)(int);
  Function(FunctionPointer anyFunction, const std::string& s)
    : function(anyFunction), name(s), m_time(0.0) {}
  FunctionPointer function;
  std::string name;
  int PerformFunction(int x) const
  {
    return function(x);
  }
  double m_time;
};

#include <vector>

const std::vector<Function> GetFunctions()
{
  std::vector<Function> v;
  v.push_back(Function(InlineZZ,"Inline"));
  v.push_back(Function(NonInlineZZ,"Non-inline"));
  return v;
}

#include <algorithm>
#include <iostream>

int main()
{
  const int n_tests = 200000;
  std::vector<Function> functions = GetFunctions();
  int x = 0;
  for (int i=0; i!=n_tests; ++i)
  {
    //Shuffle the two functions, so the compiler cannot optimize
    std::random_shuffle(functions.begin(),functions.end());
    std::for_each(functions.begin(),functions.end(),
      [&x](Function& f)
      {
        const int j = std::rand();
        boost::timer t;
        x += f.PerformFunction(j);
        f.m_time += t.elapsed();
      }
    );
  }

  std::cout << "x: " << x << '\n';
  std::for_each(functions.begin(),functions.end(),
    [&x](Function& f)
    {
      std::cout << f.name << ": " << f.m_time << " seconds\n";
    }
  );
}

 

Screen output:

 

/* Version 1.0: n_tests = 2000000000

-1507666432
-1507666432
Inline: 1.94 seconds
Non inline: 1.78 seconds

*/

/* Version 2.0: n_tests = 200000
x: -975427683
Inline: 4.29 seconds
Non-inline: 5.34 seconds

x: -975427683
Inline: 4.56 seconds
Non-inline: 5.05 seconds
*/

 

 

 

 

 

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

 

Valid XHTML 1.0 Strict

This page has been created by the tool CodeToHtml