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

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



#include <iostream>

int main()
{
  const int n_tests = 2000000000;
  double t_non_inline = 0.0;
  {
    boost::timer t;
    int x = 0;
    for (int i=0; i!=n_tests; ++i)
    {
      x += NonInlineZZ(i);
    }
    t_non_inline = t.elapsed();
    std::cout << x << '\n';
  }
  double t_inline = 0.0;
  {
    boost::timer t;
    int x = 0;
    for (int i=0; i!=n_tests; ++i)
    {
      x += InlineZZ(i);
    }
    t_inline = t.elapsed();
    std::cout << x << '\n';
  }
  std::cout
    << "Inline: " << t_inline << " seconds\n"
    << "Non inline: " << t_non_inline << " seconds\n";
}

 

Screen output:

 

-1507666432
-1507666432
Inline: 1.94 seconds
Non inline: 1.78 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