
int henrion5F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         HENRION5                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(6);
    vector<Polynomial<eltType>> polhenrion5;
    
	////////////
	//		HENRION5		//
	// 6 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5]
	polhenrion5.emplace_back("2*x0*x1*x2*x3*x4 + 2137660372");
	polhenrion5.emplace_back("5*x0*x1*x2*x3 + 1288490193*x0*x1*x2*x4 + 858993463*x0*x1*x3*x4 + 858993462*x0*x2*x3*x4 + 1288490190*x1*x2*x3*x4 + 2143018522");
	polhenrion5.emplace_back("4*x0*x1*x2 + 6*x0*x1*x3 + 6*x0*x2*x3 + 4*x1*x2*x3 + 429496733*x0*x1*x4 + 1288490193*x0*x2*x4 + 429496733*x1*x2*x4 + 1288490191*x0*x3*x4 + 1288490191*x1*x3*x4 + 429496731*x2*x3*x4 + 2147042161");
	polhenrion5.emplace_back("3*x0*x1 + 4*x0*x2 + 3*x1*x2 + 4*x0*x3 + 4*x1*x3 + 3*x2*x3 + 1717986920*x0*x4 + 1717986920*x1*x4 + 1717986920*x2*x4 + 1717986919*x3*x4 + 2147468149");
	polhenrion5.emplace_back("2*x0 + 2*x1 + 2*x2 + 2*x3 + 858993460*x4 + 2147483432");
	polhenrion5.emplace_back("x0 + 2*x1 + 3*x2 + 4*x3 + 5*x4 + 6*x5");
	////////////


    Ideal<eltType> henrion5(polhenrion5, 6, 1000000);
    nbGen=henrion5.f4();
    if(magma)
    {
        henrion5.printReducedGroebnerBasis("HENRION5", modulo);
    }
    return nbGen;
}


int henrion6F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         HENRION6                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(6);
    vector<Polynomial<eltType>> polhenrion6;
    
	////////////
	//		HENRION6		//
	// 6 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5]
	polhenrion6.emplace_back("2*x0*x1*x2*x3*x4*x5 + 742755322");
	polhenrion6.emplace_back("6*x0*x1*x2*x3*x4 + 357913947*x0*x1*x2*x3*x5 + 1431655770*x0*x1*x2*x4*x5 + 1073741828*x0*x1*x3*x4*x5 + 1431655768*x0*x2*x3*x4*x5 + 357913943*x1*x2*x3*x4*x5 + 1499147497");
	polhenrion6.emplace_back("5*x0*x1*x2*x3 + 8*x0*x1*x2*x4 + 9*x0*x1*x3*x4 + 8*x0*x2*x3*x4 + 5*x1*x2*x3*x4 + 715827887*x0*x1*x2*x5 + 7*x0*x1*x3*x5 + 7*x0*x2*x3*x5 + 715827887*x1*x2*x3*x5 + 4*x0*x1*x4*x5 + 1431655770*x0*x2*x4*x5 + 4*x1*x2*x4*x5 + 3*x0*x3*x4*x5 + 3*x1*x3*x4*x5 + 715827884*x2*x3*x4*x5 + 2079886024");
	polhenrion6.emplace_back("4*x0*x1*x2 + 6*x0*x1*x3 + 6*x0*x2*x3 + 4*x1*x2*x3 + 6*x0*x1*x4 + 8*x0*x2*x4 + 6*x1*x2*x4 + 6*x0*x3*x4 + 6*x1*x3*x4 + 4*x2*x3*x4 + 1073741827*x0*x1*x5 + 715827887*x0*x2*x5 + 1073741827*x1*x2*x5 + 715827887*x0*x3*x5 + 715827887*x1*x3*x5 + 1073741827*x2*x3*x5 + 715827885*x0*x4*x5 + 715827885*x1*x4*x5 + 715827885*x2*x4*x5 + 1073741825*x3*x4*x5 + 2144825947");
	polhenrion6.emplace_back("3*x0*x1 + 4*x0*x2 + 3*x1*x2 + 4*x0*x3 + 4*x1*x3 + 3*x2*x3 + 4*x0*x4 + 4*x1*x4 + 4*x2*x4 + 3*x3*x4 + 1431655767*x0*x5 + 1431655767*x1*x5 + 1431655767*x2*x5 + 1431655767*x3*x5 + 1431655766*x4*x5 + 2147437404");
	polhenrion6.emplace_back("2*x0 + 2*x1 + 2*x2 + 2*x3 + 2*x4 + 1789569707*x5 + 2147483289");
	////////////


    Ideal<eltType> henrion6(polhenrion6, 6, 1000000);
    nbGen=henrion6.f4();
    if(magma)
    {
        henrion6.printReducedGroebnerBasis("HENRION6", modulo);
    }
    return nbGen;
}


int henrion7F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         HENRION7                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(7);
    vector<Polynomial<eltType>> polhenrion7;
    
	////////////
	//		HENRION7		//
	// 7 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6]
	polhenrion7.emplace_back("2*x0*x1*x2*x3*x4*x5*x6 + 955883441");
	polhenrion7.emplace_back("7*x0*x1*x2*x3*x4*x5 + 306783385*x0*x1*x2*x3*x4*x6 + 1227133519*x0*x1*x2*x3*x5*x6 + 613566762*x0*x1*x2*x4*x5*x6 + 613566761*x0*x1*x3*x4*x5*x6 + 1227133516*x0*x2*x3*x4*x5*x6 + 306783380*x1*x2*x3*x4*x5*x6 + 1018741245");
	polhenrion7.emplace_back("6*x0*x1*x2*x3*x4 + 10*x0*x1*x2*x3*x5 + 12*x0*x1*x2*x4*x5 + 12*x0*x1*x3*x4*x5 + 10*x0*x2*x3*x4*x5 + 6*x1*x2*x3*x4*x5 + 613566762*x0*x1*x2*x3*x6 + 1840700278*x0*x1*x2*x4*x6 + 1533916901*x0*x1*x3*x4*x6 + 1840700278*x0*x2*x3*x4*x6 + 613566762*x1*x2*x3*x4*x6 + 1840700274*x0*x1*x2*x5*x6 + 613566764*x0*x1*x3*x5*x6 + 613566764*x0*x2*x3*x5*x6 + 1840700274*x1*x2*x3*x5*x6 + 1533916895*x0*x1*x4*x5*x6 + 613566762*x0*x2*x4*x5*x6 + 1533916895*x1*x2*x4*x5*x6 + 1840700272*x0*x3*x4*x5*x6 + 1840700272*x1*x3*x4*x5*x6 + 613566758*x2*x3*x4*x5*x6 + 1202512894");
	polhenrion7.emplace_back("5*x0*x1*x2*x3 + 8*x0*x1*x2*x4 + 9*x0*x1*x3*x4 + 8*x0*x2*x3*x4 + 5*x1*x2*x3*x4 + 8*x0*x1*x2*x5 + 12*x0*x1*x3*x5 + 12*x0*x2*x3*x5 + 8*x1*x2*x3*x5 + 9*x0*x1*x4*x5 + 12*x0*x2*x4*x5 + 9*x1*x2*x4*x5 + 8*x0*x3*x4*x5 + 8*x1*x3*x4*x5 + 5*x2*x3*x4*x5 + 920350139*x0*x1*x2*x6 + 306783385*x0*x1*x3*x6 + 306783385*x0*x2*x3*x6 + 920350139*x1*x2*x3*x6 + 306783385*x0*x1*x4*x6 + 1840700278*x0*x2*x4*x6 + 306783385*x1*x2*x4*x6 + 306783385*x0*x3*x4*x6 + 306783385*x1*x3*x4*x6 + 920350139*x2*x3*x4*x6 + 306783382*x0*x1*x5*x6 + 1840700274*x0*x2*x5*x6 + 306783382*x1*x2*x5*x6 + 1840700274*x0*x3*x5*x6 + 1840700274*x1*x3*x5*x6 + 306783382*x2*x3*x5*x6 + 306783381*x0*x4*x5*x6 + 306783381*x1*x4*x5*x6 + 306783381*x2*x4*x5*x6 + 920350136*x3*x4*x5*x6 + 1561634524");
	polhenrion7.emplace_back("4*x0*x1*x2 + 6*x0*x1*x3 + 6*x0*x2*x3 + 4*x1*x2*x3 + 6*x0*x1*x4 + 8*x0*x2*x4 + 6*x1*x2*x4 + 6*x0*x3*x4 + 6*x1*x3*x4 + 4*x2*x3*x4 + 6*x0*x1*x5 + 8*x0*x2*x5 + 6*x1*x2*x5 + 8*x0*x3*x5 + 8*x1*x3*x5 + 6*x2*x3*x5 + 6*x0*x4*x5 + 6*x1*x4*x5 + 6*x2*x4*x5 + 4*x3*x4*x5 + 1227133516*x0*x1*x6 + 920350139*x0*x2*x6 + 1227133516*x1*x2*x6 + 920350139*x0*x3*x6 + 920350139*x1*x3*x6 + 1227133516*x2*x3*x6 + 920350139*x0*x4*x6 + 920350139*x1*x4*x6 + 920350139*x2*x4*x6 + 1227133516*x3*x4*x6 + 920350137*x0*x5*x6 + 920350137*x1*x5*x6 + 920350137*x2*x5*x6 + 920350137*x3*x5*x6 + 1227133514*x4*x5*x6 + 2135808562");
	polhenrion7.emplace_back("3*x0*x1 + 4*x0*x2 + 3*x1*x2 + 4*x0*x3 + 4*x1*x3 + 3*x2*x3 + 4*x0*x4 + 4*x1*x4 + 4*x2*x4 + 3*x3*x4 + 4*x0*x5 + 4*x1*x5 + 4*x2*x5 + 4*x3*x5 + 3*x4*x5 + 1533916893*x0*x6 + 1533916893*x1*x6 + 1533916893*x2*x6 + 1533916893*x3*x6 + 1533916893*x4*x6 + 1533916892*x5*x6 + 2147367594");
	polhenrion7.emplace_back("2*x0 + 2*x1 + 2*x2 + 2*x3 + 2*x4 + 2*x5 + 1840700270*x6 + 2147483094");
	////////////


    Ideal<eltType> henrion7(polhenrion7, 7, 1000000);
    nbGen=henrion7.f4();
    if(magma)
    {
        henrion7.printReducedGroebnerBasis("HENRION7", modulo);
    }
    return nbGen;
}


int katsura10F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         KATSURA10                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(11);
    vector<Polynomial<eltType>> polkatsura10;
    
	////////////
	//		KATSURA10		//
	// 11 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]
	polkatsura10.emplace_back("x0^2 + 2*x1^2 + 2*x2^2 + 2*x3^2 + 2*x4^2 + 2*x5^2 + 2*x6^2 + 2*x7^2 + 2*x8^2 + 2*x9^2 + 2*x10^2 + 2147483646*x0");
	polkatsura10.emplace_back("2*x0*x1 + 2*x1*x2 + 2*x2*x3 + 2*x3*x4 + 2*x4*x5 + 2*x5*x6 + 2*x6*x7 + 2*x7*x8 + 2*x8*x9 + 2*x9*x10 + 2147483646*x1");
	polkatsura10.emplace_back("x1^2 + 2*x0*x2 + 2*x1*x3 + 2*x2*x4 + 2*x3*x5 + 2*x4*x6 + 2*x5*x7 + 2*x6*x8 + 2*x7*x9 + 2*x8*x10 + 2147483646*x2");
	polkatsura10.emplace_back("2*x1*x2 + 2*x0*x3 + 2*x1*x4 + 2*x2*x5 + 2*x3*x6 + 2*x4*x7 + 2*x5*x8 + 2*x6*x9 + 2*x7*x10 + 2147483646*x3");
	polkatsura10.emplace_back("x2^2 + 2*x1*x3 + 2*x0*x4 + 2*x1*x5 + 2*x2*x6 + 2*x3*x7 + 2*x4*x8 + 2*x5*x9 + 2*x6*x10 + 2147483646*x4");
	polkatsura10.emplace_back("2*x2*x3 + 2*x1*x4 + 2*x0*x5 + 2*x1*x6 + 2*x2*x7 + 2*x3*x8 + 2*x4*x9 + 2*x5*x10 + 2147483646*x5");
	polkatsura10.emplace_back("x3^2 + 2*x2*x4 + 2*x1*x5 + 2*x0*x6 + 2*x1*x7 + 2*x2*x8 + 2*x3*x9 + 2*x4*x10 + 2147483646*x6");
	polkatsura10.emplace_back("2*x3*x4 + 2*x2*x5 + 2*x1*x6 + 2*x0*x7 + 2*x1*x8 + 2*x2*x9 + 2*x3*x10 + 2147483646*x7");
	polkatsura10.emplace_back("x4^2 + 2*x3*x5 + 2*x2*x6 + 2*x1*x7 + 2*x0*x8 + 2*x1*x9 + 2*x2*x10 + 2147483646*x8");
	polkatsura10.emplace_back("2*x4*x5 + 2*x3*x6 + 2*x2*x7 + 2*x1*x8 + 2*x0*x9 + 2*x1*x10 + 2147483646*x9");
	polkatsura10.emplace_back("x0 + 2*x1 + 2*x2 + 2*x3 + 2*x4 + 2*x5 + 2*x6 + 2*x7 + 2*x8 + 2*x9 + 2*x10 + 2147483646");
	////////////


    Ideal<eltType> katsura10(polkatsura10, 11, 1000000);
    nbGen=katsura10.f4();
    if(magma)
    {
        katsura10.printReducedGroebnerBasis("KATSURA10", modulo);
    }
    return nbGen;
}


int katsura11F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         KATSURA11                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(12);
    vector<Polynomial<eltType>> polkatsura11;
    
	////////////
	//		KATSURA11		//
	// 12 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11]
	polkatsura11.emplace_back("x0^2 + 2*x1^2 + 2*x2^2 + 2*x3^2 + 2*x4^2 + 2*x5^2 + 2*x6^2 + 2*x7^2 + 2*x8^2 + 2*x9^2 + 2*x10^2 + 2*x11^2 + 2147483646*x0");
	polkatsura11.emplace_back("2*x0*x1 + 2*x1*x2 + 2*x2*x3 + 2*x3*x4 + 2*x4*x5 + 2*x5*x6 + 2*x6*x7 + 2*x7*x8 + 2*x8*x9 + 2*x9*x10 + 2*x10*x11 + 2147483646*x1");
	polkatsura11.emplace_back("x1^2 + 2*x0*x2 + 2*x1*x3 + 2*x2*x4 + 2*x3*x5 + 2*x4*x6 + 2*x5*x7 + 2*x6*x8 + 2*x7*x9 + 2*x8*x10 + 2*x9*x11 + 2147483646*x2");
	polkatsura11.emplace_back("2*x1*x2 + 2*x0*x3 + 2*x1*x4 + 2*x2*x5 + 2*x3*x6 + 2*x4*x7 + 2*x5*x8 + 2*x6*x9 + 2*x7*x10 + 2*x8*x11 + 2147483646*x3");
	polkatsura11.emplace_back("x2^2 + 2*x1*x3 + 2*x0*x4 + 2*x1*x5 + 2*x2*x6 + 2*x3*x7 + 2*x4*x8 + 2*x5*x9 + 2*x6*x10 + 2*x7*x11 + 2147483646*x4");
	polkatsura11.emplace_back("2*x2*x3 + 2*x1*x4 + 2*x0*x5 + 2*x1*x6 + 2*x2*x7 + 2*x3*x8 + 2*x4*x9 + 2*x5*x10 + 2*x6*x11 + 2147483646*x5");
	polkatsura11.emplace_back("x3^2 + 2*x2*x4 + 2*x1*x5 + 2*x0*x6 + 2*x1*x7 + 2*x2*x8 + 2*x3*x9 + 2*x4*x10 + 2*x5*x11 + 2147483646*x6");
	polkatsura11.emplace_back("2*x3*x4 + 2*x2*x5 + 2*x1*x6 + 2*x0*x7 + 2*x1*x8 + 2*x2*x9 + 2*x3*x10 + 2*x4*x11 + 2147483646*x7");
	polkatsura11.emplace_back("x4^2 + 2*x3*x5 + 2*x2*x6 + 2*x1*x7 + 2*x0*x8 + 2*x1*x9 + 2*x2*x10 + 2*x3*x11 + 2147483646*x8");
	polkatsura11.emplace_back("2*x4*x5 + 2*x3*x6 + 2*x2*x7 + 2*x1*x8 + 2*x0*x9 + 2*x1*x10 + 2*x2*x11 + 2147483646*x9");
	polkatsura11.emplace_back("x5^2 + 2*x4*x6 + 2*x3*x7 + 2*x2*x8 + 2*x1*x9 + 2*x0*x10 + 2*x1*x11 + 2147483646*x10");
	polkatsura11.emplace_back("x0 + 2*x1 + 2*x2 + 2*x3 + 2*x4 + 2*x5 + 2*x6 + 2*x7 + 2*x8 + 2*x9 + 2*x10 + 2*x11 + 2147483646");
	////////////


    Ideal<eltType> katsura11(polkatsura11, 12, 1000000);
    nbGen=katsura11.f4();
    if(magma)
    {
        katsura11.printReducedGroebnerBasis("KATSURA11", modulo);
    }
    return nbGen;
}


int katsura12F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         KATSURA12                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(13);
    vector<Polynomial<eltType>> polkatsura12;
    
	////////////
	//		KATSURA12		//
	// 13 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12]
	polkatsura12.emplace_back("x0^2 + 2*x1^2 + 2*x2^2 + 2*x3^2 + 2*x4^2 + 2*x5^2 + 2*x6^2 + 2*x7^2 + 2*x8^2 + 2*x9^2 + 2*x10^2 + 2*x11^2 + 2*x12^2 + 2147483646*x0");
	polkatsura12.emplace_back("2*x0*x1 + 2*x1*x2 + 2*x2*x3 + 2*x3*x4 + 2*x4*x5 + 2*x5*x6 + 2*x6*x7 + 2*x7*x8 + 2*x8*x9 + 2*x9*x10 + 2*x10*x11 + 2*x11*x12 + 2147483646*x1");
	polkatsura12.emplace_back("x1^2 + 2*x0*x2 + 2*x1*x3 + 2*x2*x4 + 2*x3*x5 + 2*x4*x6 + 2*x5*x7 + 2*x6*x8 + 2*x7*x9 + 2*x8*x10 + 2*x9*x11 + 2*x10*x12 + 2147483646*x2");
	polkatsura12.emplace_back("2*x1*x2 + 2*x0*x3 + 2*x1*x4 + 2*x2*x5 + 2*x3*x6 + 2*x4*x7 + 2*x5*x8 + 2*x6*x9 + 2*x7*x10 + 2*x8*x11 + 2*x9*x12 + 2147483646*x3");
	polkatsura12.emplace_back("x2^2 + 2*x1*x3 + 2*x0*x4 + 2*x1*x5 + 2*x2*x6 + 2*x3*x7 + 2*x4*x8 + 2*x5*x9 + 2*x6*x10 + 2*x7*x11 + 2*x8*x12 + 2147483646*x4");
	polkatsura12.emplace_back("2*x2*x3 + 2*x1*x4 + 2*x0*x5 + 2*x1*x6 + 2*x2*x7 + 2*x3*x8 + 2*x4*x9 + 2*x5*x10 + 2*x6*x11 + 2*x7*x12 + 2147483646*x5");
	polkatsura12.emplace_back("x3^2 + 2*x2*x4 + 2*x1*x5 + 2*x0*x6 + 2*x1*x7 + 2*x2*x8 + 2*x3*x9 + 2*x4*x10 + 2*x5*x11 + 2*x6*x12 + 2147483646*x6");
	polkatsura12.emplace_back("2*x3*x4 + 2*x2*x5 + 2*x1*x6 + 2*x0*x7 + 2*x1*x8 + 2*x2*x9 + 2*x3*x10 + 2*x4*x11 + 2*x5*x12 + 2147483646*x7");
	polkatsura12.emplace_back("x4^2 + 2*x3*x5 + 2*x2*x6 + 2*x1*x7 + 2*x0*x8 + 2*x1*x9 + 2*x2*x10 + 2*x3*x11 + 2*x4*x12 + 2147483646*x8");
	polkatsura12.emplace_back("2*x4*x5 + 2*x3*x6 + 2*x2*x7 + 2*x1*x8 + 2*x0*x9 + 2*x1*x10 + 2*x2*x11 + 2*x3*x12 + 2147483646*x9");
	polkatsura12.emplace_back("x5^2 + 2*x4*x6 + 2*x3*x7 + 2*x2*x8 + 2*x1*x9 + 2*x0*x10 + 2*x1*x11 + 2*x2*x12 + 2147483646*x10");
	polkatsura12.emplace_back("2*x5*x6 + 2*x4*x7 + 2*x3*x8 + 2*x2*x9 + 2*x1*x10 + 2*x0*x11 + 2*x1*x12 + 2147483646*x11");
	polkatsura12.emplace_back("x0 + 2*x1 + 2*x2 + 2*x3 + 2*x4 + 2*x5 + 2*x6 + 2*x7 + 2*x8 + 2*x9 + 2*x10 + 2*x11 + 2*x12 + 2147483646");
	////////////


    Ideal<eltType> katsura12(polkatsura12, 13, 1000000);
    nbGen=katsura12.f4();
    if(magma)
    {
        katsura12.printReducedGroebnerBasis("KATSURA12", modulo);
    }
    return nbGen;
}


int eco11F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         ECO11                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(11);
    vector<Polynomial<eltType>> poleco11;
    
	////////////
	//		ECO11		//
	// 11 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]
	poleco11.emplace_back("x0*x1*x10 + x1*x2*x10 + x2*x3*x10 + x3*x4*x10 + x4*x5*x10 + x5*x6*x10 + x6*x7*x10 + x7*x8*x10 + x8*x9*x10 + x0*x10 + 2147483646");
	poleco11.emplace_back("x0*x2*x10 + x1*x3*x10 + x2*x4*x10 + x3*x5*x10 + x4*x6*x10 + x5*x7*x10 + x6*x8*x10 + x7*x9*x10 + x1*x10 + 2147483645");
	poleco11.emplace_back("x0*x3*x10 + x1*x4*x10 + x2*x5*x10 + x3*x6*x10 + x4*x7*x10 + x5*x8*x10 + x6*x9*x10 + x2*x10 + 2147483644");
	poleco11.emplace_back("x0*x4*x10 + x1*x5*x10 + x2*x6*x10 + x3*x7*x10 + x4*x8*x10 + x5*x9*x10 + x3*x10 + 2147483643");
	poleco11.emplace_back("x0*x5*x10 + x1*x6*x10 + x2*x7*x10 + x3*x8*x10 + x4*x9*x10 + x4*x10 + 2147483642");
	poleco11.emplace_back("x0*x6*x10 + x1*x7*x10 + x2*x8*x10 + x3*x9*x10 + x5*x10 + 2147483641");
	poleco11.emplace_back("x0*x7*x10 + x1*x8*x10 + x2*x9*x10 + x6*x10 + 2147483640");
	poleco11.emplace_back("x0*x8*x10 + x1*x9*x10 + x7*x10 + 2147483639");
	poleco11.emplace_back("x0*x9*x10 + x8*x10 + 2147483638");
	poleco11.emplace_back("x9*x10 + 2147483637");
	poleco11.emplace_back("x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + 1");
	////////////


    Ideal<eltType> eco11(poleco11, 11, 1000000);
    nbGen=eco11.f4();
    if(magma)
    {
        eco11.printReducedGroebnerBasis("ECO11", modulo);
    }
    return nbGen;
}


int eco12F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         ECO12                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(12);
    vector<Polynomial<eltType>> poleco12;
    
	////////////
	//		ECO12		//
	// 12 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11]
	poleco12.emplace_back("x0*x1*x11 + x1*x2*x11 + x2*x3*x11 + x3*x4*x11 + x4*x5*x11 + x5*x6*x11 + x6*x7*x11 + x7*x8*x11 + x8*x9*x11 + x9*x10*x11 + x0*x11 + 2147483646");
	poleco12.emplace_back("x0*x2*x11 + x1*x3*x11 + x2*x4*x11 + x3*x5*x11 + x4*x6*x11 + x5*x7*x11 + x6*x8*x11 + x7*x9*x11 + x8*x10*x11 + x1*x11 + 2147483645");
	poleco12.emplace_back("x0*x3*x11 + x1*x4*x11 + x2*x5*x11 + x3*x6*x11 + x4*x7*x11 + x5*x8*x11 + x6*x9*x11 + x7*x10*x11 + x2*x11 + 2147483644");
	poleco12.emplace_back("x0*x4*x11 + x1*x5*x11 + x2*x6*x11 + x3*x7*x11 + x4*x8*x11 + x5*x9*x11 + x6*x10*x11 + x3*x11 + 2147483643");
	poleco12.emplace_back("x0*x5*x11 + x1*x6*x11 + x2*x7*x11 + x3*x8*x11 + x4*x9*x11 + x5*x10*x11 + x4*x11 + 2147483642");
	poleco12.emplace_back("x0*x6*x11 + x1*x7*x11 + x2*x8*x11 + x3*x9*x11 + x4*x10*x11 + x5*x11 + 2147483641");
	poleco12.emplace_back("x0*x7*x11 + x1*x8*x11 + x2*x9*x11 + x3*x10*x11 + x6*x11 + 2147483640");
	poleco12.emplace_back("x0*x8*x11 + x1*x9*x11 + x2*x10*x11 + x7*x11 + 2147483639");
	poleco12.emplace_back("x0*x9*x11 + x1*x10*x11 + x8*x11 + 2147483638");
	poleco12.emplace_back("x0*x10*x11 + x9*x11 + 2147483637");
	poleco12.emplace_back("x10*x11 + 2147483636");
	poleco12.emplace_back("x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + 1");
	////////////


    Ideal<eltType> eco12(poleco12, 12, 1000000);
    nbGen=eco12.f4();
    if(magma)
    {
        eco12.printReducedGroebnerBasis("ECO12", modulo);
    }
    return nbGen;
}


int eco13F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         ECO13                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(13);
    vector<Polynomial<eltType>> poleco13;
    
	////////////
	//		ECO13		//
	// 13 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12]
	poleco13.emplace_back("x0*x1*x12 + x1*x2*x12 + x2*x3*x12 + x3*x4*x12 + x4*x5*x12 + x5*x6*x12 + x6*x7*x12 + x7*x8*x12 + x8*x9*x12 + x9*x10*x12 + x10*x11*x12 + x0*x12 + 2147483646");
	poleco13.emplace_back("x0*x2*x12 + x1*x3*x12 + x2*x4*x12 + x3*x5*x12 + x4*x6*x12 + x5*x7*x12 + x6*x8*x12 + x7*x9*x12 + x8*x10*x12 + x9*x11*x12 + x1*x12 + 2147483645");
	poleco13.emplace_back("x0*x3*x12 + x1*x4*x12 + x2*x5*x12 + x3*x6*x12 + x4*x7*x12 + x5*x8*x12 + x6*x9*x12 + x7*x10*x12 + x8*x11*x12 + x2*x12 + 2147483644");
	poleco13.emplace_back("x0*x4*x12 + x1*x5*x12 + x2*x6*x12 + x3*x7*x12 + x4*x8*x12 + x5*x9*x12 + x6*x10*x12 + x7*x11*x12 + x3*x12 + 2147483643");
	poleco13.emplace_back("x0*x5*x12 + x1*x6*x12 + x2*x7*x12 + x3*x8*x12 + x4*x9*x12 + x5*x10*x12 + x6*x11*x12 + x4*x12 + 2147483642");
	poleco13.emplace_back("x0*x6*x12 + x1*x7*x12 + x2*x8*x12 + x3*x9*x12 + x4*x10*x12 + x5*x11*x12 + x5*x12 + 2147483641");
	poleco13.emplace_back("x0*x7*x12 + x1*x8*x12 + x2*x9*x12 + x3*x10*x12 + x4*x11*x12 + x6*x12 + 2147483640");
	poleco13.emplace_back("x0*x8*x12 + x1*x9*x12 + x2*x10*x12 + x3*x11*x12 + x7*x12 + 2147483639");
	poleco13.emplace_back("x0*x9*x12 + x1*x10*x12 + x2*x11*x12 + x8*x12 + 2147483638");
	poleco13.emplace_back("x0*x10*x12 + x1*x11*x12 + x9*x12 + 2147483637");
	poleco13.emplace_back("x0*x11*x12 + x10*x12 + 2147483636");
	poleco13.emplace_back("x11*x12 + 2147483635");
	poleco13.emplace_back("x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + 1");
	////////////


    Ideal<eltType> eco13(poleco13, 13, 1000000);
    nbGen=eco13.f4();
    if(magma)
    {
        eco13.printReducedGroebnerBasis("ECO13", modulo);
    }
    return nbGen;
}


int noon7F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         NOON7                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(7);
    vector<Polynomial<eltType>> polnoon7;
    
	////////////
	//		NOON7		//
	// 7 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6]
	polnoon7.emplace_back("10*x0*x1^2 + 10*x0*x2^2 + 10*x0*x3^2 + 10*x0*x4^2 + 10*x0*x5^2 + 10*x0*x6^2 + 2147483636*x0 + 10");
	polnoon7.emplace_back("10*x0^2*x1 + 10*x1*x2^2 + 10*x1*x3^2 + 10*x1*x4^2 + 10*x1*x5^2 + 10*x1*x6^2 + 2147483636*x1 + 10");
	polnoon7.emplace_back("10*x0^2*x2 + 10*x1^2*x2 + 10*x2*x3^2 + 10*x2*x4^2 + 10*x2*x5^2 + 10*x2*x6^2 + 2147483636*x2 + 10");
	polnoon7.emplace_back("10*x0^2*x3 + 10*x1^2*x3 + 10*x2^2*x3 + 10*x3*x4^2 + 10*x3*x5^2 + 10*x3*x6^2 + 2147483636*x3 + 10");
	polnoon7.emplace_back("10*x0^2*x4 + 10*x1^2*x4 + 10*x2^2*x4 + 10*x3^2*x4 + 10*x4*x5^2 + 10*x4*x6^2 + 2147483636*x4 + 10");
	polnoon7.emplace_back("10*x0^2*x5 + 10*x1^2*x5 + 10*x2^2*x5 + 10*x3^2*x5 + 10*x4^2*x5 + 10*x5*x6^2 + 2147483636*x5 + 10");
	polnoon7.emplace_back("10*x0^2*x6 + 10*x1^2*x6 + 10*x2^2*x6 + 10*x3^2*x6 + 10*x4^2*x6 + 10*x5^2*x6 + 2147483636*x6 + 10");
	////////////


    Ideal<eltType> noon7(polnoon7, 7, 1000000);
    nbGen=noon7.f4();
    if(magma)
    {
        noon7.printReducedGroebnerBasis("NOON7", modulo);
    }
    return nbGen;
}


int noon8F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         NOON8                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(8);
    vector<Polynomial<eltType>> polnoon8;
    
	////////////
	//		NOON8		//
	// 8 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7]
	polnoon8.emplace_back("10*x0*x1^2 + 10*x0*x2^2 + 10*x0*x3^2 + 10*x0*x4^2 + 10*x0*x5^2 + 10*x0*x6^2 + 10*x0*x7^2 + 2147483636*x0 + 10");
	polnoon8.emplace_back("10*x0^2*x1 + 10*x1*x2^2 + 10*x1*x3^2 + 10*x1*x4^2 + 10*x1*x5^2 + 10*x1*x6^2 + 10*x1*x7^2 + 2147483636*x1 + 10");
	polnoon8.emplace_back("10*x0^2*x2 + 10*x1^2*x2 + 10*x2*x3^2 + 10*x2*x4^2 + 10*x2*x5^2 + 10*x2*x6^2 + 10*x2*x7^2 + 2147483636*x2 + 10");
	polnoon8.emplace_back("10*x0^2*x3 + 10*x1^2*x3 + 10*x2^2*x3 + 10*x3*x4^2 + 10*x3*x5^2 + 10*x3*x6^2 + 10*x3*x7^2 + 2147483636*x3 + 10");
	polnoon8.emplace_back("10*x0^2*x4 + 10*x1^2*x4 + 10*x2^2*x4 + 10*x3^2*x4 + 10*x4*x5^2 + 10*x4*x6^2 + 10*x4*x7^2 + 2147483636*x4 + 10");
	polnoon8.emplace_back("10*x0^2*x5 + 10*x1^2*x5 + 10*x2^2*x5 + 10*x3^2*x5 + 10*x4^2*x5 + 10*x5*x6^2 + 10*x5*x7^2 + 2147483636*x5 + 10");
	polnoon8.emplace_back("10*x0^2*x6 + 10*x1^2*x6 + 10*x2^2*x6 + 10*x3^2*x6 + 10*x4^2*x6 + 10*x5^2*x6 + 10*x6*x7^2 + 2147483636*x6 + 10");
	polnoon8.emplace_back("10*x0^2*x7 + 10*x1^2*x7 + 10*x2^2*x7 + 10*x3^2*x7 + 10*x4^2*x7 + 10*x5^2*x7 + 10*x6^2*x7 + 2147483636*x7 + 10");
	////////////


    Ideal<eltType> noon8(polnoon8, 8, 1000000);
    nbGen=noon8.f4();
    if(magma)
    {
        noon8.printReducedGroebnerBasis("NOON8", modulo);
    }
    return nbGen;
}


int noon9F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         NOON9                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(9);
    vector<Polynomial<eltType>> polnoon9;
    
	////////////
	//		NOON9		//
	// 9 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7, x8]
	polnoon9.emplace_back("10*x0*x1^2 + 10*x0*x2^2 + 10*x0*x3^2 + 10*x0*x4^2 + 10*x0*x5^2 + 10*x0*x6^2 + 10*x0*x7^2 + 10*x0*x8^2 + 2147483636*x0 + 10");
	polnoon9.emplace_back("10*x0^2*x1 + 10*x1*x2^2 + 10*x1*x3^2 + 10*x1*x4^2 + 10*x1*x5^2 + 10*x1*x6^2 + 10*x1*x7^2 + 10*x1*x8^2 + 2147483636*x1 + 10");
	polnoon9.emplace_back("10*x0^2*x2 + 10*x1^2*x2 + 10*x2*x3^2 + 10*x2*x4^2 + 10*x2*x5^2 + 10*x2*x6^2 + 10*x2*x7^2 + 10*x2*x8^2 + 2147483636*x2 + 10");
	polnoon9.emplace_back("10*x0^2*x3 + 10*x1^2*x3 + 10*x2^2*x3 + 10*x3*x4^2 + 10*x3*x5^2 + 10*x3*x6^2 + 10*x3*x7^2 + 10*x3*x8^2 + 2147483636*x3 + 10");
	polnoon9.emplace_back("10*x0^2*x4 + 10*x1^2*x4 + 10*x2^2*x4 + 10*x3^2*x4 + 10*x4*x5^2 + 10*x4*x6^2 + 10*x4*x7^2 + 10*x4*x8^2 + 2147483636*x4 + 10");
	polnoon9.emplace_back("10*x0^2*x5 + 10*x1^2*x5 + 10*x2^2*x5 + 10*x3^2*x5 + 10*x4^2*x5 + 10*x5*x6^2 + 10*x5*x7^2 + 10*x5*x8^2 + 2147483636*x5 + 10");
	polnoon9.emplace_back("10*x0^2*x6 + 10*x1^2*x6 + 10*x2^2*x6 + 10*x3^2*x6 + 10*x4^2*x6 + 10*x5^2*x6 + 10*x6*x7^2 + 10*x6*x8^2 + 2147483636*x6 + 10");
	polnoon9.emplace_back("10*x0^2*x7 + 10*x1^2*x7 + 10*x2^2*x7 + 10*x3^2*x7 + 10*x4^2*x7 + 10*x5^2*x7 + 10*x6^2*x7 + 10*x7*x8^2 + 2147483636*x7 + 10");
	polnoon9.emplace_back("10*x0^2*x8 + 10*x1^2*x8 + 10*x2^2*x8 + 10*x3^2*x8 + 10*x4^2*x8 + 10*x5^2*x8 + 10*x6^2*x8 + 10*x7^2*x8 + 2147483636*x8 + 10");
	////////////


    Ideal<eltType> noon9(polnoon9, 9, 1000000);
    nbGen=noon9.f4();
    if(magma)
    {
        noon9.printReducedGroebnerBasis("NOON9", modulo);
    }
    return nbGen;
}


int reimer6F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         REIMER6                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(6);
    vector<Polynomial<eltType>> polreimer6;
    
	////////////
	//		REIMER6		//
	// 6 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5]
	polreimer6.emplace_back("2*x0^2 + 2147483645*x1^2 + 2*x2^2 + 2147483645*x3^2 + 2*x4^2 + 2147483645*x5^2 + 2147483646");
	polreimer6.emplace_back("2*x0^3 + 2147483645*x1^3 + 2*x2^3 + 2147483645*x3^3 + 2*x4^3 + 2147483645*x5^3 + 2147483646");
	polreimer6.emplace_back("2*x0^4 + 2147483645*x1^4 + 2*x2^4 + 2147483645*x3^4 + 2*x4^4 + 2147483645*x5^4 + 2147483646");
	polreimer6.emplace_back("2*x0^5 + 2147483645*x1^5 + 2*x2^5 + 2147483645*x3^5 + 2*x4^5 + 2147483645*x5^5 + 2147483646");
	polreimer6.emplace_back("2*x0^6 + 2147483645*x1^6 + 2*x2^6 + 2147483645*x3^6 + 2*x4^6 + 2147483645*x5^6 + 2147483646");
	polreimer6.emplace_back("2*x0^7 + 2147483645*x1^7 + 2*x2^7 + 2147483645*x3^7 + 2*x4^7 + 2147483645*x5^7 + 2147483646");
	////////////


    Ideal<eltType> reimer6(polreimer6, 6, 1000000);
    nbGen=reimer6.f4();
    if(magma)
    {
        reimer6.printReducedGroebnerBasis("REIMER6", modulo);
    }
    return nbGen;
}


int reimer7F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         REIMER7                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(7);
    vector<Polynomial<eltType>> polreimer7;
    
	////////////
	//		REIMER7		//
	// 7 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6]
	polreimer7.emplace_back("2*x0^2 + 2147483645*x1^2 + 2*x2^2 + 2147483645*x3^2 + 2*x4^2 + 2147483645*x5^2 + 2*x6^2 + 2147483646");
	polreimer7.emplace_back("2*x0^3 + 2147483645*x1^3 + 2*x2^3 + 2147483645*x3^3 + 2*x4^3 + 2147483645*x5^3 + 2*x6^3 + 2147483646");
	polreimer7.emplace_back("2*x0^4 + 2147483645*x1^4 + 2*x2^4 + 2147483645*x3^4 + 2*x4^4 + 2147483645*x5^4 + 2*x6^4 + 2147483646");
	polreimer7.emplace_back("2*x0^5 + 2147483645*x1^5 + 2*x2^5 + 2147483645*x3^5 + 2*x4^5 + 2147483645*x5^5 + 2*x6^5 + 2147483646");
	polreimer7.emplace_back("2*x0^6 + 2147483645*x1^6 + 2*x2^6 + 2147483645*x3^6 + 2*x4^6 + 2147483645*x5^6 + 2*x6^6 + 2147483646");
	polreimer7.emplace_back("2*x0^7 + 2147483645*x1^7 + 2*x2^7 + 2147483645*x3^7 + 2*x4^7 + 2147483645*x5^7 + 2*x6^7 + 2147483646");
	polreimer7.emplace_back("2*x0^8 + 2147483645*x1^8 + 2*x2^8 + 2147483645*x3^8 + 2*x4^8 + 2147483645*x5^8 + 2*x6^8 + 2147483646");
	////////////


    Ideal<eltType> reimer7(polreimer7, 7, 1000000);
    nbGen=reimer7.f4();
    if(magma)
    {
        reimer7.printReducedGroebnerBasis("REIMER7", modulo);
    }
    return nbGen;
}


int reimer8F4(bool magma)
{
    cout << "#########################################################" << endl;
    cout << "#                         REIMER8                        #" << endl;
    cout << "#########################################################" << endl << endl;
    eltType::setModulo(modulo);
    int nbGen;
    Monomial::initMonomial(8);
    vector<Polynomial<eltType>> polreimer8;
    
	////////////
	//		REIMER8		//
	// 8 vars: AbstractAlgebra.Generic.MPoly{AbstractAlgebra.GFElem{Int64}}[x0, x1, x2, x3, x4, x5, x6, x7]
	polreimer8.emplace_back("2*x0^2 + 2147483645*x1^2 + 2*x2^2 + 2147483645*x3^2 + 2*x4^2 + 2147483645*x5^2 + 2*x6^2 + 2147483645*x7^2 + 2147483646");
	polreimer8.emplace_back("2*x0^3 + 2147483645*x1^3 + 2*x2^3 + 2147483645*x3^3 + 2*x4^3 + 2147483645*x5^3 + 2*x6^3 + 2147483645*x7^3 + 2147483646");
	polreimer8.emplace_back("2*x0^4 + 2147483645*x1^4 + 2*x2^4 + 2147483645*x3^4 + 2*x4^4 + 2147483645*x5^4 + 2*x6^4 + 2147483645*x7^4 + 2147483646");
	polreimer8.emplace_back("2*x0^5 + 2147483645*x1^5 + 2*x2^5 + 2147483645*x3^5 + 2*x4^5 + 2147483645*x5^5 + 2*x6^5 + 2147483645*x7^5 + 2147483646");
	polreimer8.emplace_back("2*x0^6 + 2147483645*x1^6 + 2*x2^6 + 2147483645*x3^6 + 2*x4^6 + 2147483645*x5^6 + 2*x6^6 + 2147483645*x7^6 + 2147483646");
	polreimer8.emplace_back("2*x0^7 + 2147483645*x1^7 + 2*x2^7 + 2147483645*x3^7 + 2*x4^7 + 2147483645*x5^7 + 2*x6^7 + 2147483645*x7^7 + 2147483646");
	polreimer8.emplace_back("2*x0^8 + 2147483645*x1^8 + 2*x2^8 + 2147483645*x3^8 + 2*x4^8 + 2147483645*x5^8 + 2*x6^8 + 2147483645*x7^8 + 2147483646");
	polreimer8.emplace_back("2*x0^9 + 2147483645*x1^9 + 2*x2^9 + 2147483645*x3^9 + 2*x4^9 + 2147483645*x5^9 + 2*x6^9 + 2147483645*x7^9 + 2147483646");
	////////////


    Ideal<eltType> reimer8(polreimer8, 8, 1000000);
    nbGen=reimer8.f4();
    if(magma)
    {
        reimer8.printReducedGroebnerBasis("REIMER8", modulo);
    }
    return nbGen;
}

