#include <iostream>
using namespace std;


/*condition en b
    la somme des nombres egale 19
FsumNUM(N) donne la somme des nombres dans N
*/
//numérologie , (somme des unité en M) == N
//FsumNUM(N) => N mod 10 + FsumNUM(N/10)
template <int N>
struct SUMNUM{
    enum {VAR = N%10 + SUMNUM<N/10>::VAR};
};
//FsumNUM(0) => 0
template <>
struct SUMNUM<0>{
    enum {VAR = 0};
};

/*condition C i
    le chffre 9 apparait au moin une fois
Fhave(M,N) donne 1 si N a apparait dans M
*/
//il y a au moin N dans la décomposition numérologique de M
//Fhave(M,N) => ((M mod 10 = N ) + Fhave(M/10)
template <int M, int N>
struct HAVE{
    enum {VAR = (M%10==N) | HAVE<M/10,N>::VAR};
};
//Fhave(0,N) => (0)
template <int N>
struct HAVE<0,N>{
    enum {VAR = 0};
};


//avoir le chiffre à la position N
//Fget(M,N) => Fget(M/10,N-1)
template <int M, int N>
struct GET{
    enum{VAR=GET<M/10,N-1>::VAR};
};
//Fget(M,0) => M%10
template <int M>
struct GET<M,0>{
    enum{VAR=M%10};
};

//Fget(0,N) => 0
template <int N>
struct GET<0,N>{
    enum{VAR=0};
};

//Fget(0,N) => 0
template <>
struct GET<0,0>{
    enum{VAR=0};
};

/*condition C ii
    le chiffre à la position des dizaine et centaine sont egal
Fposequ(M,N,K) retourne 1 si le chiffre à la position n est egal 
à celui de la position K dans M
0 => unité
1 => dizaine
2 => centaine
...
condition C iii est couverte par cette fonction
*/
//le chiffre à la position N est égale à la position K
//Fposequ(M,N,K) => Fget(M,1)==Fget(M,2)
template <int M, int N, int K>
struct FUNKYEQUAL{
    enum{VAR = (GET<M,1>::VAR == GET<M,2>::VAR)};
};

/*
toute condition réuni
*/
//toute condition réuni
//Fcondition(M) => FsumNUM(M)==19 and Fhave(M,9) and Fposequ(M,1,2) and Fposequ(5,6)
template <int M>
struct CONDITION{
    enum {VAR = (SUMNUM<M>::VAR == 19) & HAVE<M,9>::VAR & FUNKYEQUAL<M,1,2>::VAR & FUNKYEQUAL<M,5,6>::VAR};
};

//pour tout les nombre inférieur ou égal à N
//Fpourcond(M) => Fcondition(M) + Fpourcond(M-1)
template <int M>
struct POURCONDITION{
    enum {VAR = CONDITION<M>::VAR + POURCONDITION<M-1>::VAR};
    static inline void EXEC()
    {
        if (CONDITION<M>::VAR)
        cout << M << endl;
        POURCONDITION<M-1>::EXEC();
    }
};
//Fpourcond(0) => 0
template <>
struct POURCONDITION<0>{
    enum {VAR = 0};
    static inline void EXEC()
    {
        
    }   
};

//
int main()
{
    cout << "resultat\n";
    cout << POURCONDITION<999999>::VAR <<endl;
    return 0;
}