#ifndef GF2MATRICES_H_PMM_01_29_09_10_41_AM_PMM
#define GF2MATRICES_H_PMM_01_29_09_10_41_AM_PMM

#ifndef NULL
#define NULL 0
#endif


class Vector2;
class VectorList2;
class Orbit2;
class Matrix2;
class Group2;
class GroupList2;
class Vector3;
class VectorList3;
class Orbit3;
class Matrix3;
class Group3;
class GroupList3;
class Vector4;
class VectorList4;
class Orbit4;
class Matrix4;
class Group4;
class GroupList4;
class Vector5;
class VectorList5;
class Orbit5;
class Matrix5;
class Group5;
class GroupList5;
class GenerateGLG2;
class GenerateAll2;
class GenerateGLG3;
class GenerateAll3;
class GenerateGLG4;
class GenerateAll4;
class GenerateGLG5;
class GenerateAll5;

class Vector2
{
public:
	// constructors
	Vector2();//tested
	Vector2(const Vector2 &x);//tested
	Vector2(int x0,int x1);//tested
	// type converters
	Vector2(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Vector2(char *x);//tested
	operator char*() { char * rv = new char[3]; rv[0] = Data[0]+'0'; rv[1] = Data[1]+'0'; rv[2] = '\0'; return rv; }//tested
	// destructor
	~Vector2(); //tested
	// operator overloads
	Vector2 &operator=(const Vector2 &x); //tested
	Vector2 &operator+=(Vector2 &x);//tested
	Vector2 &operator*=(Matrix2 &x);//tested
	Vector2 &operator*=(int x);//tested
	Vector2 operator+(Vector2 &x);//tested
	int operator*(Vector2 &x);//tested
	Vector2 operator*(int x);//tested
	Vector2 operator*(Matrix2 &x);//tested
	int operator==(Vector2 &x);//tested
	int operator!=(Vector2 &x);//tested
	int operator<(Vector2 &x);//tested
	int operator<=(Vector2 &x);//tested
	int operator>(Vector2 &x);//tested
	int operator>=(Vector2 &x);//tested
	// accessors
	Vector2 * GetNext();//tested
	void SetNext(Vector2 * NewNext);//tested
	int Get(int x);//tested
	void Set(int x,int NewVal);//tested
	int Order(void);//tested
	// utilities
	int isZero(void);//tested
	int isOne(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int IntVal(void);//tested
protected:
	Vector2 *Next;
	int Data[2];
};

class VectorList2
{
friend VectorList3;
friend VectorList4;
friend VectorList5;
public:
	// constructors
	VectorList2(); //tested
	VectorList2(const VectorList2 &x);//tested
	VectorList2(Vector2 &x);//tested
	VectorList2(Vector2 *x);//tested
	VectorList2(int x,int y);//tested
	// destructor
	~VectorList2();//tested
	// operator overloads
	VectorList2 &operator=(const VectorList2 &x);//tested
	VectorList2 &operator+=(const VectorList2 &x);//tested
	VectorList2 &operator*=(VectorList2 &x);//tested
	VectorList2 &operator-=(VectorList2 &x);//tested
	VectorList2 operator+(const VectorList2 &x); // union//tested
	VectorList2 operator*(VectorList2 &x); // intersection//tested
	VectorList2 operator-(VectorList2 &x); // set difference//tested
	VectorList2 operator-(); // complement//tested
	int operator==(VectorList2 &x);//tested
	int operator!=(VectorList2 &x);//tested
	int operator<(VectorList2 &x);//tested
	int operator<=(VectorList2 &x);//tested
	int operator>(VectorList2 &x);//tested
	int operator>=(VectorList2 &x);//tested
	// accessors
	Vector2 * GetFirstVector(void);//tested
	Vector2 * GetNextVector(void);//tested
	Vector2 * GetVector(int x);//tested
	VectorList2 * GetNext(void);//tested
	void SetNext(VectorList2 * NewNext);//tested
	void Add(Vector2 &x);//tested
	void Add(int x,int y);//tested
	int Delete(Vector2 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Vector2 &x);//tested
	int Contains(int x,int y);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
	void GenerateAll(int x);//tested
protected:
	VectorList2 *Next;
	Vector2 *Head;
	Vector2 *Tail;
	int Count;
	Vector2 *Current;
};

class Orbit2
{
friend Orbit3;
friend Orbit4;
friend Orbit5;
public:
	// constructors
	Orbit2();//tested
	Orbit2(const Orbit2 &x);//tested
	Orbit2(VectorList2 &x);//tested
	Orbit2(VectorList2 *x);//tested
	Orbit2(Vector2 &x);//tested
	Orbit2(Vector2 *x);//tested
	// destructor
	~Orbit2();
	// operator overloads
	Orbit2 &operator=(const Orbit2 &x);//tested
	Orbit2 &operator+=(const Orbit2 &x);//tested
	Orbit2 &operator*=(Orbit2 &x);//tested
	Orbit2 &operator-=(Orbit2 &x);//tested
	Orbit2 operator+(const Orbit2 &x); // union//tested
	Orbit2 operator*(Orbit2 &x); // intersection//tested
	Orbit2 operator-(Orbit2 &x); // set difference//tested
	Orbit2 operator-(); // complement//tested
	int operator==(Orbit2 &x);//tested
	int operator!=(Orbit2 &x);//tested
	int operator<(Orbit2 &x);//tested
	int operator<=(Orbit2 &x);//tested
	int operator>(Orbit2 &x);//tested
	int operator>=(Orbit2 &x);//tested
	// accessors
	VectorList2 * GetFirstList(void);//tested
	VectorList2 * GetNextList(void);//tested
	VectorList2 * GetList(int x);//tested
	Orbit2 * GetNext(void);//tested
	void SetNext(Orbit2 * NewNext);//tested
	void Add(VectorList2 &x);//tested
	int Delete(VectorList2 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(VectorList2 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
protected:
	Orbit2 *Next;
	VectorList2 *Head;
	VectorList2 *Tail;
	int Count;
	VectorList2 *Current;
};

class Matrix2
{
friend Matrix3;
public:
	//constructors
	Matrix2();//tested
	Matrix2(const Matrix2 &x);//tested
	Matrix2(int x00,int x11);//tested
	Matrix2(int x00,int x01,int x10,int x11);//tested
	Matrix2(Vector2 Row0,Vector2 Row1);//tested
	//type converters
	Matrix2(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Matrix2(char *x);//tested
	operator char*() { char * rv = new char[5]; rv[0] = Data[0][0]+'0'; rv[1] = Data[0][1]+'0'; rv[2] = Data[1][0]+'0'; rv[3] = Data[1][1]+'0'; rv[4] = '\0'; return rv; }//tested
	Matrix2(Vector2 Diagonal);//tested
	operator Vector2() { Vector2  rv; rv.Set(0,Data[0][0]); rv.Set(1,Data[1][1]); return rv; }//tested
	//destructor
	virtual ~Matrix2();//tested
	// operator overloads
	Matrix2 &operator=(const Matrix2 &x);//tested
	Matrix2 &operator+=(Matrix2 &x);//tested
	Matrix2 &operator*=(Matrix2 &x);//tested
	Matrix2 operator+(Matrix2 &x);//tested
	Matrix2 operator*(Matrix2 &x);//tested
	Vector2 operator*(Vector2 &x);//tested
	int operator==(Matrix2 &x);//tested
	int operator!=(Matrix2 &x);//tested
	int operator<(Matrix2 &x);//tested
	int operator<=(Matrix2 &x);//tested
	int operator>(Matrix2 &x);//tested
	int operator>=(Matrix2 &x);//tested
	// accessors
	Matrix2 * GetNext();//tested
	void SetNext(Matrix2 * NewNext);//tested
	int Get(int x,int y);//tested
	void Set(int x,int y,int NewVal);//tested
	void InsertRow(Vector2 &V,int Row);//tested
	void InsertCol(Vector2 &V,int Col);//tested
	Vector2 GetRow(int Row);//tested
	Vector2 GetCol(int Col);//tested
	//utilities
	int GetEigenPoly(void);//tested
	int Determinant(void);//tested
	int Order(void);//tested
	int Singular(void);//tested
	int NonSingular(void);//tested
	Matrix2 Invert(void);//tested
	Matrix2 Transpose(void);//tested
	int Gaussian(Vector2 &Constants);//tested
	int isZero(void);//tested
	int isIdentity(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	char *SerializeRow(int Row);//tested
	char *SerializeRowNL(int Row);//tested
	int IntVal(void);//tested
	int Minor(int x,int y);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Decomposable(void);//tested
	int GetLeftComponent(void); //tested
	int GetRightComponent(void);//tested
	int isPermutation(void);//tested
	char * GetPermutation(void);//tested
protected:
	int EigenDet(void);//tested
	Matrix2 *Next;
	int Data[2][2];
};

class Group2
{
friend Group3;
friend Group4;
friend Group5;
public:
	// constructors
	Group2();//tested
	Group2(Group2 &x);//tested
	Group2(Matrix2 &x);//tested
	Group2(Matrix2 *x);//tested
	// destructor
	~Group2();//tested
	// operator overloads
	Group2 &operator=(Group2 &x);//tested
	Group2 &operator+=(Group2 &x);//tested
	Group2 &operator^=(Group2 &x);//tested
	Group2 &operator*=(Group2 &x);//tested
	Group2 &operator-=(Group2 &x);//tested
	Group2 operator+(Group2 &x); // union//tested
	Group2 operator^(Group2 &x); // closed union //tested
	Group2 operator*(Group2 &x); // intersection//tested
	Group2 operator-(Group2 &x); // set difference//tested
	Group2 operator-(); // complement//tested
	int operator==(Group2 &x);//tested
	int operator!=(Group2 &x);//tested
	int operator<(Group2 &x);//tested
	int operator<=(Group2 &x);//tested
	int operator>(Group2 &x);//tested
	int operator>=(Group2 &x);//tested
	// accessors
	Matrix2 * GetFirstMatrix(void);//tested
	Matrix2 * GetNextMatrix(void);//tested
	Matrix2 * GetMatrix(int x);//tested
	Group2 * GetNext(void);//tested
	void SetNext(Group2 * NewNext);//tested
	void Add(Matrix2 &x);//tested
	int Delete(Matrix2 *x);//tested
	int Order(void);//tested
	// utilites
	void Close(void);//tested
	int Close(int Limit);//tested
	Group2 Conjugate(Matrix2 &x);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateGLG(void);//tested
	void GenerateAll(void);//tested
	void GenerateS2(void);//tested
	void GenerateS3(void);//tested
	Orbit2 GetOrbits(void);//tested
	Orbit2 GetVOrbits(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Matrix2 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateOrder(int x);//tested
	void GLGSplit(Group2 &O1,Group2 &O2,Group2 &O3);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Decomposable(void);//tested
	int * GetLeftComponent(void);//tested
	int * GetRightComponent(void);//tested
protected:
	Group2 *Next;
	Matrix2 *Head;
	Matrix2 *Tail;
	int Count;
	Matrix2 *Current;
};


class GroupList2
{
friend GroupList3;
friend GroupList4;
friend GroupList5;
public:
	// constructors
	GroupList2();//tested
	GroupList2(const GroupList2 &x);//tested
	GroupList2(Group2 &x);//tested
	GroupList2(Group2 *x);//tested
	GroupList2(Matrix2 &x);//tested
	GroupList2(Matrix2 *x);//tested
	// destructor
	~GroupList2();//tested
	// operator overloads
	GroupList2 &operator=(const GroupList2 &x);//tested
	GroupList2 &operator+=(const GroupList2 &x);//tested
	GroupList2 &operator*=(GroupList2 &x);//tested
	GroupList2 &operator-=(GroupList2 &x);//tested
	GroupList2 operator+(const GroupList2 &x); // union//tested
	GroupList2 operator*(GroupList2 &x); // intersection//tested
	GroupList2 operator-(GroupList2 &x); // set difference//tested
	GroupList2 operator-(); // complement//tested
	int operator==(GroupList2 &x);//tested
	int operator!=(GroupList2 &x);//tested
	int operator<(GroupList2 &x);//tested
	int operator<=(GroupList2 &x);//tested
	int operator>(GroupList2 &x);//tested
	int operator>=(GroupList2 &x);//tested
	// accessors
	Group2 * GetFirstGroup(void);//tested
	Group2 * GetNextGroup(void);//tested
	Group2 * GetGroup(int x);//tested
	GroupList2 * GetNext(void);//tested
	void SetNext(GroupList2 * NewNext);//tested
	void Add(Group2 &x);//tested
	int Delete(Group2 *x);//tested
	int Order(void);//tested
	// utilites
	void CloseAll(void);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateS2Conj(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Group2 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
protected:
	GroupList2 *Next;
	Group2 *Head;
	Group2 *Tail;
	int Count;
	Group2 *Current;
};

class Vector3
{
public:
	// constructors
	Vector3();//tested
	Vector3(const Vector3 &x);//tested
	Vector3(int x0,int x1,int x2);//tested
	// type converters
	Vector3(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Vector3(char *x);//tested
	operator char*() { char * rv = new char[4]; rv[0] = Data[0]+'0'; rv[1] = Data[1]+'0'; rv[2] = Data[2]+'0'; rv[3] = '\0'; return rv; }//tested
	Vector3(Vector2 &x);
	// destructor
	~Vector3(); //tested
	// operator overloads
	Vector3 &operator=(const Vector3 &x);//tested
	Vector3 &operator+=(Vector3 &x);//tested
	Vector3 &operator*=(Matrix3 &x);//tested
	Vector3 &operator*=(int x);//tested
	Vector3 operator+(Vector3 &x);//tested
	int operator*(Vector3 &x);//tested
	Vector3 operator*(int x);//tested
	Vector3 operator*(Matrix3 &x);//tested
	int operator==(Vector3 &x);//tested
	int operator!=(Vector3 &x);//tested
	int operator<(Vector3 &x);//tested
	int operator<=(Vector3 &x);//tested
	int operator>(Vector3 &x);//tested
	int operator>=(Vector3 &x);//tested
	// accessors
	Vector3 * GetNext();//tested
	void SetNext(Vector3 * NewNext);//tested
	Vector2 GetV2(int x);//tested
	int Get(int x);//tested
	void Set(int x,int NewVal);//tested
	int Order(void);//tested
	// utilities
	int isZero(void);//tested
	int isOne(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int IntVal(void);//tested
protected:
	Vector3 *Next;
	int Data[3];
};

class VectorList3
{
friend VectorList4;
friend VectorList5;
public:
	// constructors
	VectorList3();//tested
	VectorList3(const VectorList3 &x);//tested
	VectorList3(Vector3 &x);//tested
	VectorList3(Vector3 *x);//tested
	VectorList3(int x,int y,int z);//tested
	VectorList3(VectorList2 &x);//tested
	// destructor
	~VectorList3();//tested
	// operator overloads
	VectorList3 &operator=(const VectorList3 &x);//tested
	VectorList3 &operator+=(const VectorList3 &x);//tested
	VectorList3 &operator*=(VectorList3 &x);//tested
	VectorList3 &operator-=(VectorList3 &x);//tested
	VectorList3 operator+(const VectorList3 &x);//tested
	VectorList3 operator*(VectorList3 &x); // intersection//tested
	VectorList3 operator-(VectorList3 &x); // set difference//tested
	VectorList3 operator-(); // complement//tested
	int operator==(VectorList3 &x);//tested
	int operator!=(VectorList3 &x);//tested
	int operator<(VectorList3 &x);//tested
	int operator<=(VectorList3 &x);//tested
	int operator>(VectorList3 &x);//tested
	int operator>=(VectorList3 &x);//tested
	// accessors
	Vector3 * GetFirstVector(void);//tested
	Vector3 * GetNextVector(void);//tested
	Vector3 * GetVector(int x);//tested
	VectorList2 GetVL2(int x);//tested
	VectorList3 * GetNext(void);//tested
	void SetNext(VectorList3 * NewNext);//tested
	void Add(Vector3 &x);//tested
	void Add(int x,int y,int z);//tested
	int Delete(Vector3 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Vector3 &x);//tested
	int Contains(int x,int y,int z);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
	void GenerateAll(int x);//tested
protected:
	VectorList3 *Next;
	Vector3 *Head;
	Vector3 *Tail;
	int Count;
	Vector3 *Current;
};

class Orbit3
{
friend Orbit4;
friend Orbit5;
public:
	// constructors
	Orbit3();//tested
	Orbit3(const Orbit3 &x);//tested
	Orbit3(VectorList3 &x);//tested
	Orbit3(VectorList3 *x);//tested
	Orbit3(Vector3 &x);//tested
	Orbit3(Vector3 *x);//tested
	Orbit3(Orbit2 &x);//tested
	// destructor
	~Orbit3();
	// operator overloads
	Orbit3 &operator=(const Orbit3 &x);//tested
	Orbit3 &operator+=(const Orbit3 &x);//tested
	Orbit3 operator+(const Orbit3 &x);//tested
	Orbit3 operator*(Orbit3 &x); // intersection//tested
	Orbit3 operator-(Orbit3 &x); // set difference//tested
	Orbit3 operator-(); // complement//tested
	int operator==(Orbit3 &x);//tested
	int operator!=(Orbit3 &x);//tested
	int operator<(Orbit3 &x);//tested
	int operator<=(Orbit3 &x);//tested
	int operator>(Orbit3 &x);//tested
	int operator>=(Orbit3 &x);//tested
	// accessors
	VectorList3 * GetFirstList(void);//tested
	VectorList3 * GetNextList(void);//tested
	VectorList3 * GetList(int x);//tested
	Orbit2 GetO2(int x);//tested
	Orbit3 * GetNext(void);//tested
	void SetNext(Orbit3 * NewNext);//tested
	void Add(VectorList3 &x);//tested
	int Delete(VectorList3 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(VectorList3 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
protected:
	Orbit3 *Next;
	VectorList3 *Head;
	VectorList3 *Tail;
	int Count;
	VectorList3 *Current;
};

class Matrix3
{
friend Matrix4;
public:
	//constructors
	Matrix3();//tested
	Matrix3(const Matrix3 &x);//tested
	Matrix3(int x00,int x11, int x22);//tested
	Matrix3(int x00,int x01, int x02, int x10,int x11, int x12, int x20,int x21, int x22);//tested
	Matrix3(Vector3 Row0,Vector3 Row1,Vector3 Row2);//tested
	Matrix3(Matrix2 Left,int Right);//tested
	Matrix3(int Left,Matrix2 Right);//tested
	//type converters
	Matrix3(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Matrix3(char *x);//tested
	operator char*() { char *rv = new char[10]; rv[0] = Data[0][0] + '0';rv[1] = Data[0][1] + '0';rv[2] = Data[0][2] + '0';
							rv[3] = Data[1][0] + '0';rv[4] = Data[1][1] + '0';rv[5] = Data[1][2] + '0';
							rv[6] = Data[2][0] + '0';rv[7] = Data[2][1] + '0';rv[8] = Data[2][2] + '0';
							rv[9] = '\0'; return rv; }//tested
	Matrix3(Vector3 Diagonal);//tested
	operator Vector3() { Vector3 rv; rv.Set(0,Data[0][0]); rv.Set(1,Data[1][1]); rv.Set(2,Data[2][2]); return rv; }//tested
	Matrix3(Matrix2 &x);//tested
	//destructor
	virtual ~Matrix3();//tested
	// operator overloads
	Matrix3 &operator=(const Matrix3 &x);//tested
	Matrix3 &operator+=(Matrix3 &x);//tested
	Matrix3 &operator*=(Matrix3 &x);//tested
	Matrix3 operator+(Matrix3 &x);//tested
	Matrix3 operator*(Matrix3 &x);//tested
	Vector3 operator*(Vector3 &x);//tested
	int operator==(Matrix3 &x);//tested
	int operator!=(Matrix3 &x);//tested
	int operator<(Matrix3 &x);//tested
	int operator<=(Matrix3 &x);//tested
	int operator>(Matrix3 &x);//tested
	int operator>=(Matrix3 &x);//tested
	// accessors
	Matrix3 * GetNext();//tested
	void SetNext(Matrix3 * NewNext);//tested
	int Get(int x,int y);//tested
	void Set(int x,int y,int NewVal);//tested
	Matrix2 Get2x2(int x,int y);//tested
	void Set(int x,int y,Matrix2 NewVal);//tested
	void InsertRow(Vector2 &V,int Row,int Col);//tested
	void InsertCol(Vector2 &V,int Row,int Col);//tested
	Vector2 GetRow2(int Row,int Col);//tested
	Vector2 GetCol2(int Row,int Col);//tested
	void InsertRow(Vector3 &V,int Row);//tested
	void InsertCol(Vector3 &V,int Col);//tested
	Vector3 GetRow(int Row);//tested
	Vector3 GetCol(int Col);//tested
	//utilities
	int GetEigenPoly(void);//tested
	int Determinant(void);//tested
	int Order(void);//tested
	int Singular(void);//tested
	int NonSingular(void);//tested
	Matrix3 Invert(void);//tested
	Matrix3 Transpose(void);//tested
	int Gaussian(Vector3 &Constants);//tested
	int isZero(void);//tested
	int isIdentity(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	char *SerializeRow(int Row);//tested
	char *SerializeRowNL(int Row);//tested
	int IntVal(void);//tested
	Matrix2 Minor(int x,int y);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Reducible3(void);//tested
	int Reducible4(void);//tested
	int Decomposable1(void);//tested
	int Decomposable2(void);//tested
	Matrix2 GetLeftComponent(void);//tested
	Matrix2 GetRightComponent(void);//tested
	int isPermutation(void);//tested
	char * GetPermutation(void);//tested
protected:
	int EigenDet(void);//tested
	Matrix3 *Next;
	int Data[3][3];
};

class Group3
{
friend Group4;
friend Group5;
public:
	// constructors
	Group3();//tested
	Group3(Group3 &x);//tested
	Group3(Matrix3 &x);//tested
	Group3(Matrix3 *x);//tested
	Group3(Group2 &x);//tested
	// destructor
	~Group3();//tested
	// operator overloads
	Group3 &operator=(Group3 &x);//tested
	Group3 &operator+=(Group3 &x);//tested
	Group3 &operator^=(Group3 &x);//tested
	Group3 &operator*=(Group3 &x);//tested
	Group3 &operator-=(Group3 &x);//tested
	Group3 operator+(Group3 &x);//tested
	Group3 operator^(Group3 &x); // closed union//tested
	Group3 operator*(Group3 &x); // intersection//tested
	Group3 operator-(Group3 &x); // set difference//tested
	Group3 operator-(); // complement//tested
	int operator==(Group3 &x);//tested
	int operator!=(Group3 &x);//tested
	int operator<(Group3 &x);//tested
	int operator<=(Group3 &x);//tested
	int operator>(Group3 &x);//tested
	int operator>=(Group3 &x);//tested
	// accessors
	Matrix3 * GetFirstMatrix(void);//tested
	Matrix3 * GetNextMatrix(void);//tested
	Matrix3 * GetMatrix(int x);//tested
	Group3 * GetNext(void);//tested
	void SetNext(Group3 * NewNext);//tested
	void Add(Matrix3 &x);//tested
	int Delete(Matrix3 *x);//tested
	int Order(void);//tested
	// utilites
	void Close(void);//tested
	int Close(int Limit);//tested
	Group3 Conjugate(Matrix3 &x);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateGLG(void);//tested
	void GenerateAll(void);//tested
	void GenerateS2(void);//tested
	void GenerateS3(void);//tested
	void GenerateS4H(void);//tested
	void GenerateS4V(void);//tested
	Orbit3 GetOrbits(void);//tested
	Orbit3 GetVOrbits(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Matrix3 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateOrder(int x);//tested
	void GLGSplit(Group3 &O1,Group3 &O2,Group3 &O3,Group3 &O4, Group3 &O5, Group3 &O6,Group3 &O7);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Reducible3(void);//tested
	int Reducible4(void);//tested
	int Decomposable1(void);//tested
	int Decomposable2(void);//tested
	Group2 GetLeftComponent(void);//tested
	Group2 GetRightComponent(void);//tested
	Group2 Get2x2(int x,int y);//tested
protected:
	Group3 *Next;
	Matrix3 *Head;
	Matrix3 *Tail;
	int Count;
	Matrix3 *Current;
};


class GroupList3
{
friend GroupList4;
friend GroupList5;
public:
	// constructors
	GroupList3();//tested
	GroupList3(const GroupList3 &x);//tested
	GroupList3(Group3 &x);//tested
	GroupList3(Group3 *x);//tested
	GroupList3(Matrix3 &x);//tested
	GroupList3(Matrix3 *x);//tested
	GroupList3(GroupList2 &x);//tested
	// destructor
	~GroupList3();
	// operator overloads
	GroupList3 &operator=(const GroupList3 &x);//tested
	GroupList3 &operator+=(const GroupList3 &x);//tested
	GroupList3 &operator*=(GroupList3 &x);//tested
	GroupList3 &operator-=(GroupList3 &x);//tested
	GroupList3 operator+(const GroupList3 &x);//tested
	GroupList3 operator*(GroupList3 &x); // intersection//tested
	GroupList3 operator-(GroupList3 &x); // set difference//tested
	//GroupList3 operator-(); // complement not practical, 2^512 subsets
	int operator==(GroupList3 &x);//tested
	int operator!=(GroupList3 &x);//tested
	int operator<(GroupList3 &x);//tested
	int operator<=(GroupList3 &x);//tested
	int operator>(GroupList3 &x);//tested
	int operator>=(GroupList3 &x);//tested
	// accessors
	Group3 * GetFirstGroup(void);//tested
	Group3 * GetNextGroup(void);//tested
	Group3 * GetGroup(int x);//tested
	GroupList3 * GetNext(void);//tested
	void SetNext(GroupList3 * NewNext);//tested
	void Add(Group3 &x);//tested
	int Delete(Group3 *x);//tested
	int Order(void);//tested
	GroupList2 Get2x2(int x,int y);//tested
	// utilites
	void CloseAll(void);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateS2Conj(void);//tested
	void GenerateS3Conj(void);//tested
	void GenerateS4HConj(void);//tested
	void GenerateS4VConj(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Group3 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	//void GenerateAll(void); // not practical, 2^512 subsets enumeration isn't practical either.
protected:
	GroupList3 *Next;
	Group3 *Head;
	Group3 *Tail;
	int Count;
	Group3 *Current;
};

class Vector4
{
public:
	// constructors
	Vector4();//tested
	Vector4(const Vector4 &x);//tested
	Vector4(int x0,int x1,int x2,int x3);//tested
	// type converters
	Vector4(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Vector4(char *x);//tested
	operator char*() { char * rv = new char[5];rv[0]=Data[0]+'0';rv[1]=Data[1]+'0';rv[2]=Data[2]+'0';rv[3]=Data[3]+'0';rv[4]='\0';return rv; }//tested
	Vector4(Vector3 &x);//tested
	Vector4(Vector2 &x);//tested
	// destructor
	~Vector4(); //tested
	// operator overloads
	Vector4 &operator=(const Vector4 &x); //tested
	Vector4 &operator+=(Vector4 &x);//tested
	Vector4 &operator*=(Matrix4 &x);//tested
	Vector4 &operator*=(int x);//tested
	Vector4 operator+(Vector4 &x);//tested
	int operator*(Vector4 &x);//tested
	Vector4 operator*(int x);//tested
	Vector4 operator*(Matrix4 &x);//tested
	int operator==(Vector4 &x);//tested
	int operator!=(Vector4 &x);//tested
	int operator<(Vector4 &x);//tested
	int operator<=(Vector4 &x);//tested
	int operator>(Vector4 &x);//tested
	int operator>=(Vector4 &x);//tested
	// accessors
	Vector4 * GetNext();//tested
	void SetNext(Vector4 * NewNext);//tested
	Vector2 GetV2(int x);//tested
	Vector3 GetV3(int x);//tested
	int Get(int x);//tested
	void Set(int x,int NewVal);//tested
	int Order(void);//tested
	// utilities
	int isZero(void);//tested
	int isOne(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int IntVal(void);//tested
protected:
	Vector4 *Next;
	int Data[4];
};

class VectorList4
{
friend VectorList5;
public:
	// constructors
	VectorList4();//tested
	VectorList4(const VectorList4 &x);//tested
	VectorList4(Vector4 &x);//tested
	VectorList4(Vector4 *x);//tested
	VectorList4(int x,int y,int z,int w);//tested
	VectorList4(VectorList2 &x);//tested
	VectorList4(VectorList3 &x);//tested
	// destructor
	~VectorList4();//tested
	// operator overloads
	VectorList4 &operator=(const VectorList4 &x);//tested
	VectorList4 &operator+=(const VectorList4 &x);//tested
	VectorList4 operator+(const VectorList4 &x);//tested
	VectorList4 operator*(VectorList4 &x); // intersection//tested
	VectorList4 operator-(VectorList4 &x); // set difference//tested
	VectorList4 operator-(); // complement//tested
	int operator==(VectorList4 &x);//tested
	int operator!=(VectorList4 &x);//tested
	int operator<(VectorList4 &x);//tested
	int operator<=(VectorList4 &x);//tested
	int operator>(VectorList4 &x);//tested
	int operator>=(VectorList4 &x);//tested
	// accessors
	Vector4 * GetFirstVector(void);//tested
	Vector4 * GetNextVector(void);//tested
	Vector4 * GetVector(int x);//tested
	VectorList2 GetVL2(int x);//tested
	VectorList3 GetVL3(int x);//tested
	VectorList4 * GetNext(void);//tested
	void SetNext(VectorList4 * NewNext);//tested
	void Add(Vector4 &x);//tested
	void Add(int x,int y,int z,int w);//tested
	int Delete(Vector4 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Vector4 &x);//tested
	int Contains(int x,int y,int z,int w);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
	void GenerateAll(int x);//tested
protected:
	VectorList4 *Next;
	Vector4 *Head;
	Vector4 *Tail;
	int Count;
	Vector4 *Current;
};

class Orbit4
{
friend Orbit5;
public:
	// constructors
	Orbit4();//tested
	Orbit4(const Orbit4 &x);//tested
	Orbit4(VectorList4 &x);//tested
	Orbit4(VectorList4 *x);//tested
	Orbit4(Vector4 &x);//tested
	Orbit4(Vector4 *x);//tested
	Orbit4(Orbit2 &x);//tested
	Orbit4(Orbit3 &x);//tested
	// destructor
	~Orbit4();//tested
	// operator overloads
	Orbit4 &operator=(const Orbit4 &x);//tested
	Orbit4 &operator+=(const Orbit4 &x);//tested
	Orbit4 operator+(const Orbit4 &x);//tested
	Orbit4 operator*(Orbit4 &x); // intersection//tested
	Orbit4 operator-(Orbit4 &x); // set difference//tested
	Orbit4 operator-(); // complement//tested
	int operator==(Orbit4 &x);//tested
	int operator!=(Orbit4 &x);//tested
	int operator<(Orbit4 &x);//tested
	int operator<=(Orbit4 &x);//tested
	int operator>(Orbit4 &x);//tested
	int operator>=(Orbit4 &x);//tested
	// accessors
	VectorList4 * GetFirstList(void);//tested
	VectorList4 * GetNextList(void);//tested
	VectorList4 * GetList(int x);//tested
	Orbit2 GetO2(int x);//tested
	Orbit3 GetO3(int x);//tested
	Orbit4 * GetNext(void);//tested
	void SetNext(Orbit4 * NewNext);//tested
	void Add(VectorList4 &x);//tested
	int Delete(VectorList4 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(VectorList4 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
protected:
	Orbit4 *Next;
	VectorList4 *Head;
	VectorList4 *Tail;
	int Count;
	VectorList4 *Current;
};

class Matrix4
{
friend Matrix5;
public:
	//constructors
	Matrix4();//tested
	Matrix4(const Matrix4 &x);//tested
	Matrix4(int x00,int x11,int x22, int x33);//tested
	Matrix4(int x00,int x01,int x02,int x03,int x10,int x11,int x12,int x13,int x20,int x21,int x22,int x23,int x30,int x31,int x32,int x33);//tested
	Matrix4(Vector4 Row0,Vector4 Row1,Vector4 Row3,Vector4 Row4);//tested
	Matrix4(Matrix3 Left,int Right);//tested
	Matrix4(int Left,Matrix3 Right);//tested
	Matrix4(Matrix2 Left,int Middle,int Right);//tested
	Matrix4(int Left,Matrix2 Middle,int Right);//tested
	Matrix4(int Left,int Middle,Matrix2 Right);//tested
	Matrix4(Matrix2 Left,Matrix2 Right);//tested
	//type converters
	Matrix4(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Matrix4(char *x);//tested
	operator char*() {char *rv = new char[17];
						rv[0]=Data[0][0]+'0';rv[1]=Data[0][1]+'0';rv[2]=Data[0][2]+'0';rv[3]=Data[0][3]+'0';
						rv[4]=Data[1][0]+'0';rv[5]=Data[1][1]+'0';rv[6]=Data[1][2]+'0';rv[7]=Data[1][3]+'0';
						rv[8]=Data[2][0]+'0';rv[9]=Data[2][1]+'0';rv[10]=Data[2][2]+'0';rv[11]=Data[2][3]+'0';
						rv[12]=Data[3][0]+'0';rv[13]=Data[3][1]+'0';rv[14]=Data[3][2]+'0';rv[15]=Data[3][3]+'0';
						rv[16]='\0';return rv; }//tested
	Matrix4(Vector4 Diagonal);//tested
	operator Vector4() {Vector4 rv; rv.Set(0,Data[0][0]); rv.Set(1,Data[1][1]); rv.Set(2,Data[2][2]); rv.Set(3,Data[3][3]); return rv; }//tested
	Matrix4(Matrix3 &x);//tested
	Matrix4(Matrix2 &x);//tested
	//destructor
	virtual ~Matrix4();//tested
	// operator overloads
	Matrix4 &operator=(const Matrix4 &x);//tested
	Matrix4 &operator+=(Matrix4 &x);//tested
	Matrix4 &operator*=(Matrix4 &x);//tested
	Matrix4 operator+(Matrix4 &x);//tested
	Matrix4 operator*(Matrix4 &x);//tested
	Vector4 operator*(Vector4 &x);//tested
	int operator==(Matrix4 &x);//tested
	int operator!=(Matrix4 &x);//tested
	int operator<(Matrix4 &x);//tested
	int operator<=(Matrix4 &x);//tested
	int operator>(Matrix4 &x);//tested
	int operator>=(Matrix4 &x);//tested
	// accessors
	Matrix4 * GetNext();//tested
	void SetNext(Matrix4 * NewNext);//tested
	int Get(int x,int y);//tested
	Matrix2 Get2x2(int Row,int Col);//tested
	Matrix3 Get3x3(int Row,int Col);//tested
	Vector2 GetRow2(int Row,int Col);//tested
	Vector2 GetCol2(int Row,int Col);//tested
	Vector3 GetRow3(int Row,int Col);//tested
	Vector3 GetCol3(int Row,int Col);//tested
	void Set(int Row,int Col,Matrix2 NewVal);//tested
	void Set(int Row,int Col,Matrix3 NewVal);//tested
	void InsertRow(Vector2 &V,int Row,int Col);//tested
	void InsertCol(Vector2 &V,int Row,int Col);//tested
	void InsertRow(Vector3 &V,int Row,int Col);//tested
	void InsertCol(Vector3 &V,int Row,int Col);//tested
	void Set(int x,int y,int NewVal);//tested
	void InsertRow(Vector4 &V,int Row);//tested
	void InsertCol(Vector4 &V,int Col);//tested
	Vector4 GetRow(int Row);//tested
	Vector4 GetCol(int Col);//tested
	//utilities
	int GetEigenPoly(void);//tested
	int Determinant(void);//tested
	int Order(void);//tested
	int Singular(void);//tested
	int NonSingular(void);//tested
	Matrix4 Invert(void);//tested
	Matrix4 Transpose(void);//tested
	int Gaussian(Vector4 &Constants);//tested
	int isZero(void);//tested
	int isIdentity(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	char *SerializeRow(int Row);//tested
	char *SerializeRowNL(int Row);//tested
	int IntVal(void);//tested
	Matrix3 Minor(int x,int y);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Reducible3(void);//tested
	int Reducible4(void);//tested
	int Reducible5(void);//tested
	int Reducible6(void);//tested
	int Decomposable1(void);//tested
	int Decomposable2(void);//tested
	int Decomposable3(void);//tested
	Matrix3 GetLeftComponent(void);//tested
	Matrix3 GetRightComponent(void);//tested
	Matrix2 GetLeft2x2(void);//tested
	Matrix2 GetRight2x2(void);//tested
	int isPermutation(void);//tested
	char * GetPermutation(void);//tested
protected:
	int EigenDet(void);//tested
	Matrix4 *Next;
	int Data[4][4];
};

class Group4
{
friend Group5;
public:
	// constructors
	Group4();//tested
	Group4(Group4 &x);//tested
	Group4(Matrix4 &x);//tested
	Group4(Matrix4 *x);//tested
	Group4(Group3 &x);//tested
	Group4(Group2 &x);//tested
	// destructor
	~Group4();//tested
	// operator overloads
	Group4 &operator=(Group4 &x);//tested
	Group4 &operator+=(Group4 &x);//tested
	Group4 &operator^=(Group4 &x);//tested
	Group4 &operator*=(Group4 &x);//tested
	Group4 &operator-=(Group4 &x);//tested
	Group4 operator+(Group4 &x);//tested
	Group4 operator^(Group4 &x); // closed union//tested
	Group4 operator*(Group4 &x); // intersection//tested
	Group4 operator-(Group4 &x); // set difference//tested
	Group4 operator-(); // complement//tested
	int operator==(Group4 &x);//tested
	int operator!=(Group4 &x);//tested
	int operator<(Group4 &x);//tested
	int operator<=(Group4 &x);//tested
	int operator>(Group4 &x);//tested
	int operator>=(Group4 &x);//tested
	// accessors
	Matrix4 * GetFirstMatrix(void);//tested
	Matrix4 * GetNextMatrix(void);//tested
	Matrix4 * GetMatrix(int x);//tested
	Group3 Get3x3(int x,int y);//tested
	Group2 Get2x2(int x,int y);//tested
	Group4 * GetNext(void);//tested
	void SetNext(Group4 * NewNext);//tested
	void Add(Matrix4 &x);//tested
	int Delete(Matrix4 *x);//tested
	int Order(void);//tested
	// utilites
	void Close(void);//tested
	int Close(int Limit);//tested
	Group4 Conjugate(Matrix4 &x);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateGLG(void);//tested
	void GenerateAll(void);//tested
	void GenerateS2(void);//tested
	void GenerateS2A(void);//tested
	void GenerateS3(void);//tested
	void GenerateS3A(void);
	void GenerateS3B(void);
	void GenerateS4(void);//tested
	void GenerateS4A(void);//tested
	void GenerateS4B(void);//tested
	void GenerateS4C(void);//tested
	void GenerateS4D(void);//tested
	void GenerateS4E(void);//tested
	void GenerateS4F(void);//tested
	void GenerateS4G(void);//tested
	void GenerateS4H(void);//tested
	void GenerateS5H(void);//tested
	void GenerateS5V(void);//tested
	void GenerateS5A(void);//tested
	Orbit4 GetOrbits(void);//tested
	Orbit4 GetVOrbits(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Matrix4 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateOrder(int x);//tested
	void GLGSplit(Group4 &O1,Group4 &O2,Group4 &O3, Group4 &O4, Group4 &O5, Group4 &O6, Group4 &O7,
				  Group4 &O8,Group4 &O9,Group4 &O10,Group4 &O11,Group4 &O12,Group4 &O13,Group4 &O14,Group4 &O15);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Reducible3(void);//tested
	int Reducible4(void);//tested
	int Reducible5(void);//tested
	int Reducible6(void);//tested
	int Decomposable1(void);//tested
	int Decomposable2(void);//tested
	int Decomposable3(void);//tested
	Group3 GetLeftComponent(void);//tested
	Group3 GetRightComponent(void);//tested
	Group2 GetLeft2x2(void);//tested
	Group2 GetRight2x2(void);//tested
protected:
	Group4 *Next;
	Matrix4 *Head;
	Matrix4 *Tail;
	int Count;
	Matrix4 *Current;
};


class GroupList4
{
friend GroupList5;
public:
	// constructors
	GroupList4();//tested
	GroupList4(const GroupList4 &x);//tested
	GroupList4(Group4 &x);//tested
	GroupList4(Group4 *x);//tested
	GroupList4(Matrix4 &x);//tested
	GroupList4(Matrix4 *x);//tested
	GroupList4(GroupList3 &x);//tested
	GroupList4(GroupList2 &x);//tested
	// destructor
	~GroupList4();//tested
	// operator overloads
	GroupList4 &operator=(const GroupList4 &x);//tested
	GroupList4 &operator+=(const GroupList4 &x);//tested
	GroupList4 &operator*=(GroupList4 &x);//tested
	GroupList4 &operator-=(GroupList4 &x);//tested
	GroupList4 operator+(const GroupList4 &x);//tested
	GroupList4 operator*(GroupList4 &x); // intersection//tested
	GroupList4 operator-(GroupList4 &x); // set difference//tested
	//GroupList4 operator-(); // complement not practical, 2^65536 subsets
	int operator==(GroupList4 &x);//tested
	int operator!=(GroupList4 &x);//tested
	int operator<(GroupList4 &x);//tested
	int operator<=(GroupList4 &x);//tested
	int operator>(GroupList4 &x);//tested
	int operator>=(GroupList4 &x);//tested
	// accessors
	Group4 * GetFirstGroup(void);//tested
	Group4 * GetNextGroup(void);//tested
	Group4 * GetGroup(int x);//tested
	GroupList3 Get3x3(int x,int y);//tested
	GroupList2 Get2x2(int x,int y);//tested
	GroupList4 * GetNext(void);//tested
	void SetNext(GroupList4 * NewNext);//tested
	void Add(Group4 &x);//tested
	int Delete(Group4 *x);//tested
	int Order(void);//tested
	// utilites
	void CloseAll(void);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateS2Conj(void);//tested
	void GenerateS2AConj(void);//tested
	void GenerateS3Conj(void);//tested
	void GenerateS3AConj(void);//tested
	void GenerateS3BConj(void);//tested
	void GenerateS4Conj(void);//tested
	void GenerateS4AConj(void);//tested
	void GenerateS4BConj(void);//tested
	void GenerateS4CConj(void);//tested
	void GenerateS4DConj(void);//tested
	void GenerateS4EConj(void);//tested
	void GenerateS4FConj(void);//tested
	void GenerateS4GConj(void);//tested
	void GenerateS4HConj(void);//tested
	void GenerateS5HConj(void);//tested
	void GenerateS5VConj(void);//tested
	void GenerateS5AConj(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Group4 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	//void GenerateAll(void); // not practical, 2^65536 subsets
protected:
	GroupList4 *Next;
	Group4 *Head;
	Group4 *Tail;
	int Count;
	Group4 *Current;
};

class Vector5
{
public:
	// constructors
	Vector5();//tested
	Vector5(const Vector5 &x);//tested
	Vector5(int x0,int x1,int x2,int x3,int x4);//tested
	// type converters
	Vector5(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Vector5(char *x);//tested
	operator char*() {char * rv= new char[6]; rv[0]=Data[0]+'0'; rv[1]=Data[1]+'0'; rv[2]=Data[2]+'0'; rv[3]=Data[3]+'0'; rv[4]=Data[4]+'0'; rv[5]='\0'; return rv; }//tested
	Vector5(Vector4 &x);//tested
	Vector5(Vector3 &x);//tested
	Vector5(Vector2 &x);//tested
	// destructor
	~Vector5(); 
	// operator overloads
	Vector5 &operator=(const Vector5 &x); //tested
	Vector5 &operator+=(Vector5 &x);//tested
	Vector5 &operator*=(Matrix5 &x);//tested
	Vector5 &operator*=(int x);//tested
	Vector5 operator+(Vector5 &x);//tested
	int operator*(Vector5 &x);//tested
	Vector5 operator*(int x);//tested
	Vector5 operator*(Matrix5 &x);//tested
	int operator==(Vector5 &x);//tested
	int operator!=(Vector5 &x);//tested
	int operator<(Vector5 &x);//tested
	int operator<=(Vector5 &x);//tested
	int operator>(Vector5 &x);//tested
	int operator>=(Vector5 &x);//tested
	// accessors
	Vector5 * GetNext();//tested
	void SetNext(Vector5 * NewNext);//tested
	int Get(int x);//tested
	void Set(int x,int NewVal);//tested
	int Order(void);//tested
	Vector2 GetV2(int x);//tested
	Vector3 GetV3(int x);//tested
	Vector4 GetV4(int x);//tested
	// utilities
	int isZero(void);//tested
	int isOne(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int IntVal(void);//tested
protected:
	Vector5 *Next;
	int Data[5];
};

class VectorList5
{
public:
	// constructors
	VectorList5();//tested
	VectorList5(const VectorList5 &x);//tested
	VectorList5(Vector5 &x);//tested
	VectorList5(Vector5 *x);//tested
	VectorList5(int x,int y,int z,int w,int v);//tested
	VectorList5(VectorList2 &x);//tested
	VectorList5(VectorList3 &x);//tested
	VectorList5(VectorList4 &x);//tested
	// destructor
	~VectorList5();
	// operator overloads
	VectorList5 &operator=(const VectorList5 &x);//tested
	VectorList5 &operator+=(const VectorList5 &x);//tested
	VectorList5 operator+(const VectorList5 &x);//tested
	VectorList5 operator*(VectorList5 &x); // intersection//tested
	VectorList5 operator-(VectorList5 &x); // set difference//tested
	VectorList5 operator-(); // complement//tested
	int operator==(VectorList5 &x);//tested
	int operator!=(VectorList5 &x);//tested
	int operator<(VectorList5 &x);//tested
	int operator<=(VectorList5 &x);//tested
	int operator>(VectorList5 &x);//tested
	int operator>=(VectorList5 &x);//tested
	// accessors
	Vector5 * GetFirstVector(void);//tested
	Vector5 * GetNextVector(void);//tested
	Vector5 * GetVector(int x);//tested
	VectorList2 GetVL2(int x);//tested
	VectorList3 GetVL3(int x);//tested
	VectorList4 GetVL4(int x);//tested
	VectorList5 * GetNext(void);//tested
	void SetNext(VectorList5 * NewNext);//tested
	void Add(Vector5 &x);//tested
	void Add(int x,int y,int z,int w,int v);//tested
	int Delete(Vector5 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Vector5 &x);//tested
	int Contains(int x,int y,int z,int w,int v);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateAll(void);//tested
	void GenerateAll(int x);//tested
protected:
	VectorList5 *Next;
	Vector5 *Head;
	Vector5 *Tail;
	int Count;
	Vector5 *Current;
};

class Orbit5
{
public:
	// constructors
	Orbit5();//tested
	Orbit5(const Orbit5 &x);//tested
	Orbit5(VectorList5 &x);//tested
	Orbit5(VectorList5 *x);//tested
	Orbit5(Vector5 &x);//tested
	Orbit5(Vector5 *x);//tested
	Orbit5(Orbit2 &x);//tested
	Orbit5(Orbit3 &x);//tested
	Orbit5(Orbit4 &x);//tested
	// destructor
	~Orbit5();//tested
	// operator overloads
	Orbit5 &operator=(const Orbit5 &x);//tested
	Orbit5 &operator+=(const Orbit5 &x);//tested
	Orbit5 operator+(const Orbit5 &x);//tested
	Orbit5 operator*(Orbit5 &x); // intersection//tested
	Orbit5 operator-(Orbit5 &x); // set difference//tested
	//Orbit5 operator-(); // complement not practical 4 billion sets
	int operator==(Orbit5 &x);//tested
	int operator!=(Orbit5 &x);//tested
	int operator<(Orbit5 &x);//tested
	int operator<=(Orbit5 &x);//tested
	int operator>(Orbit5 &x);//tested
	int operator>=(Orbit5 &x);//tested
	// accessors
	VectorList5 * GetFirstList(void);//tested
	VectorList5 * GetNextList(void);//tested
	VectorList5 * GetList(int x);//tested
	Orbit2 GetO2(int x);//tested
	Orbit3 GetO3(int x);//tested
	Orbit4 GetO4(int x);//tested
	Orbit5 * GetNext(void);//tested
	void SetNext(Orbit5 * NewNext);//tested
	void Add(VectorList5 &x);//tested
	int Delete(VectorList5 *x);//tested
	int Order(void);//tested
	// utilites
	void Sort(void);//tested
	void Clear(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(VectorList5 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	//void GenerateAll(void); // Not Practical 4 billion sets
protected:
	Orbit5 *Next;
	VectorList5 *Head;
	VectorList5 *Tail;
	int Count;
	VectorList5 *Current;
};

class Matrix5
{
public:
	//constructors
	Matrix5();
	Matrix5(const Matrix5 &x);//tested
	Matrix5(int x00,int x11,int x22,int x33,int x44);//tested
	Matrix5(int x00,int x01,int x02,int x03,int x04,int x10,int x11,int x12,int x13,int x14,int x20,int x21,int x22,int x23,int x24,int x30,int x31,int x32,int x33,int x34,int x40,int x41,int x42,int x43,int x44);//tested
	Matrix5(Vector5 Row0,Vector5 Row1,Vector5 Row2,Vector5 Row3,Vector5 Row4);//tested
	Matrix5(Matrix4 Left,int Right);//tested
	Matrix5(int Left,Matrix4 Right);//tested
	Matrix5(Matrix3 Left,Matrix2 Right);//tested
	Matrix5(Matrix2 Left,Matrix3 Right);//tested
	Matrix5(Matrix3 Left,int Middle,int Right);//tested
	Matrix5(int Left,Matrix3 Middle,int Right);//tested
	Matrix5(int Left,int Middle,Matrix3 Right);//tested
	Matrix5(Matrix2 Left,Matrix2 Middle,int Right);//tested
	Matrix5(Matrix2 Left,int Middle,Matrix2 Right);//tested
	Matrix5(int Left,Matrix2 Middle,Matrix2 Right);//tested
	Matrix5(Matrix2 Left,int Middle1,int Middle2,int Right);//tested
	Matrix5(int Left,Matrix2 Middle1,int Middle2,int Right);//tested
	Matrix5(int Left,int Middle1,Matrix2 Middle2,int Right);//tested
	Matrix5(int Left,int Middle1,int Middle2,Matrix2 Right);//tested
	// type converters
	Matrix5(int xAll);//tested
	operator int() { return IntVal(); }//tested
	Matrix5(char *x);//tested
	operator char*() {char * rv= new char[26];
						rv[0]=Data[0][0]+'0';rv[1]=Data[0][1]+'0';rv[2]=Data[0][2]+'0';rv[3]=Data[0][3]+'0';rv[4]=Data[0][4]+'0';
						rv[5]=Data[1][0]+'0';rv[6]=Data[1][1]+'0';rv[7]=Data[1][2]+'0';rv[8]=Data[1][3]+'0';rv[9]=Data[1][4]+'0';
						rv[10]=Data[2][0]+'0';rv[11]=Data[2][1]+'0';rv[12]=Data[2][2]+'0';rv[13]=Data[2][3]+'0';rv[14]=Data[2][4]+'0';
						rv[15]=Data[3][0]+'0';rv[16]=Data[3][1]+'0';rv[17]=Data[3][2]+'0';rv[18]=Data[3][3]+'0';rv[19]=Data[3][4]+'0';
						rv[20]=Data[4][0]+'0';rv[21]=Data[4][1]+'0';rv[22]=Data[4][2]+'0';rv[23]=Data[4][3]+'0';rv[24]=Data[4][4]+'0';
						rv[25]='\0'; return rv; }//tested
	Matrix5(Vector5 Diagonal);//tested
	operator Vector5() {Vector5 rv; rv.Set(0,Data[0][0]); rv.Set(1,Data[1][1]); rv.Set(2,Data[2][2]); rv.Set(3,Data[3][3]); rv.Set(4,Data[4][4]); return rv; }//tested
	Matrix5(Matrix2 &x);//tested
	Matrix5(Matrix3 &x);//tested
	Matrix5(Matrix4 &x);//tested
	//destructor
	virtual ~Matrix5();//tested
	// operator overloads
	Matrix5 &operator=(const Matrix5 &x);//tested
	Matrix5 &operator+=(Matrix5 &x);//tested
	Matrix5 &operator*=(Matrix5 &x);//tested
	Matrix5 operator+(Matrix5 &x);//tested
	Matrix5 operator*(Matrix5 &x);//tested
	Vector5 operator*(Vector5 &x);//tested
	int operator==(Matrix5 &x);//tested
	int operator!=(Matrix5 &x);//tested
	int operator<(Matrix5 &x);//tested
	int operator<=(Matrix5 &x);//tested
	int operator>(Matrix5 &x);//tested
	int operator>=(Matrix5 &x);//tested
	// accessors
	Matrix5 * GetNext();//tested
	void SetNext(Matrix5 * NewNext);//tested
	int Get(int x,int y);//tested
	Matrix2 Get2x2(int Row,int Col);//tested
	Matrix3 Get3x3(int Row,int Col);//tested
	Matrix4 Get4x4(int Row,int Col);//tested
	void Set(int Row,int Col,Matrix2 NewVal);//tested
	void Set(int Row,int Col,Matrix3 NewVal);//tested
	void Set(int Row,int Col,Matrix4 NewVal);//tested
	Vector2 GetRow2(int Row,int Col);//tested
	Vector2 GetCol2(int Row,int Col);//tested
	Vector3 GetRow3(int Row,int Col);//tested
	Vector3 GetCol3(int Row,int Col);//tested
	Vector4 GetRow4(int Row,int Col);//tested
	Vector4 GetCol4(int Row,int Col);//tested
	void InsertRow(Vector2 &V,int Row,int Col);//tested
	void InsertCol(Vector2 &V,int Row,int Col);//tested
	void InsertRow(Vector3 &V,int Row,int Col);//tested
	void InsertCol(Vector3 &V,int Row,int Col);//tested
	void InsertRow(Vector4 &V,int Row,int Col);//tested
	void InsertCol(Vector4 &V,int Row,int Col);//tested
	void Set(int x,int y,int NewVal);//tested
	void InsertRow(Vector5 &V,int Row);//tested
	void InsertCol(Vector5 &V,int Col);//tested
	Vector5 GetRow(int Row);//tested
	Vector5 GetCol(int Col);//tested
	//utilities
	int GetEigenPoly(void);//tested
	int Determinant(void);//tested
	int Order(void);//tested
	int Singular(void);//tested
	int NonSingular(void);//tested
	Matrix5 Invert(void);//tested
	Matrix5 Transpose(void);//tested
	int Gaussian(Vector5 &Constants);//tested
	int isZero(void);//tested
	int isIdentity(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	char *SerializeRow(int Row);//tested
	char *SerializeRowNL(int Row);//tested
	int IntVal(void);//tested
	Matrix4 Minor(int x,int y);//tested
	int isPermutation(void);//tested
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Reducible3(void);//tested
	int Reducible4(void);//tested
	int Reducible5(void);//tested
	int Reducible6(void);//tested
	int Reducible7(void);//tested
	int Reducible8(void);//tested
	int Decomposable1(void);//tested
	int Decomposable2(void);//tested
	int Decomposable3(void);//tested
	int Decomposable4(void);//tested
	Matrix4 GetLeftComponent(void);//tested
	Matrix4 GetRightComponent(void);//tested
	Matrix3 GetLeft3x3(void);//tested
	Matrix3 GetRight3x3(void);//tested
	Matrix2 GetLeft2x2(void);//tested
	Matrix2 GetRight2x2(void);//tested
	char * GetPermutation(void);//tested
protected:
	int EigenDet(void);//tested
	Matrix5 *Next;
	int Data[5][5];
};

class Group5
{
public:
	// constructors
	Group5();//tested
	Group5(Group5 &x);//tested
	Group5(Matrix5 &x);//tested
	Group5(Matrix5 *x);//tested
	Group5(Group2 &x);//tested
	Group5(Group3 &x);//tested
	Group5(Group4 &x);//tested
	// destructor
	~Group5();//tested
	// operator overloads
	Group5 &operator=(Group5 &x);//tested
	Group5 &operator+=(Group5 &x);//tested
	Group5 &operator^=(Group5 &x);//tested
	Group5 &operator*=(Group5 &x);//tested
	Group5 &operator-=(Group5 &x);//tested
	Group5 operator+(Group5 &x);//tested
	Group5 operator^(Group5 &x); // closed union//tested
	Group5 operator*(Group5 &x); // intersection//tested
	Group5 operator-(Group5 &x); // set difference//tested
	Group5 operator-(); // complement//never tested
	int operator==(Group5 &x);//tested
	int operator!=(Group5 &x);//tested
	int operator<(Group5 &x);//tested
	int operator<=(Group5 &x);//tested
	int operator>(Group5 &x);//tested
	int operator>=(Group5 &x);//tested
	// accessors
	Matrix5 * GetFirstMatrix(void);//tested
	Matrix5 * GetNextMatrix(void);//tested
	Matrix5 * GetMatrix(int x);//tested
	Group2 Get2x2(int x,int y);//tested
	Group3 Get3x3(int x,int y);//tested
	Group4 Get4x4(int x,int y);//tested
	Group5 * GetNext(void);//tested
	void SetNext(Group5 * NewNext);//tested
	void Add(Matrix5 &x);//tested
	int Delete(Matrix5 *x);//tested
	int Order(void);//tested
	// utilites
	void Close(void);//tested
	int Close(int Limit);//tested
	Group5 Conjugate(Matrix5 &x);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateGLG(void);//tested
	void GenerateAll(void);//Requires 64bit OS
	void GenerateS2(void);//tested
	void GenerateS3(void);//tested
	void GenerateS4(void);//tested
	void GenerateS5(void);//tested
	void GenerateS5A(void);//tested
	void GenerateS5B(void);//tested
	void GenerateS5C(void);//tested
	void GenerateS5D(void);//tested
	void GenerateS6H(void);//tested
	void GenerateS6V(void);//tested
	Orbit5 GetOrbits(void);//tested
	Orbit5 GetVOrbits(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Matrix5 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	void GenerateOrder(int x);//tested
	void GLGSplit(Group5 &O1, Group5 &O2, Group5 &O3, Group5 &O4, Group5 &O5, Group5 &O6, Group5 &O7,
				  Group5 &O8, Group5 &O9, Group5 &O10,Group5 &O11,Group5 &O12,Group5 &O13,Group5 &O14,Group5 &O15,
				  Group5 &O16,Group5 &O17,Group5 &O18,Group5 &O19,Group5 &O20,Group5 &O21,Group5 &O22,Group5 &O23,
				  Group5 &O24,Group5 &O25,Group5 &O26,Group5 &O27,Group5 &O28,Group5 &O29,Group5 &O30,Group5 &O31
			  );//requires 64 bit OS
	int Reducible1(void);//tested
	int Reducible2(void);//tested
	int Reducible3(void);//tested
	int Reducible4(void);//tested
	int Reducible5(void);//tested
	int Reducible6(void);//tested
	int Reducible7(void);//tested
	int Reducible8(void);//tested
	int Decomposable1(void);//tested
	int Decomposable2(void);//tested
	int Decomposable3(void);//tested
	int Decomposable4(void);//tested
	Group4 GetLeftComponent(void);//tested
	Group4 GetRightComponent(void);//tested
	Group3 GetLeft3x3(void);//tested
	Group3 GetRight3x3(void);//tested
	Group2 GetLeft2x2(void);//tested
	Group2 GetRight2x2(void);//tested
protected:
	Group5 *Next;
	Matrix5 *Head;
	Matrix5 *Tail;
	int Count;
	Matrix5 *Current;
};


class GroupList5
{
public:
	// constructors
	GroupList5();//tested
	GroupList5(const GroupList5 &x);//tested
	GroupList5(Group5 &x);//tested
	GroupList5(Group5 *x);//tested
	GroupList5(Matrix5 &x);//tested
	GroupList5(Matrix5 *x);//tested
	GroupList5(GroupList2 &x);//tested
	GroupList5(GroupList3 &x);//tested
	GroupList5(GroupList4 &x);//tested
	// destructor
	~GroupList5();//tested
	// operator overloads
	GroupList5 &operator=(const GroupList5 &x);//tested
	GroupList5 &operator+=(const GroupList5 &x);//tested
	GroupList5 &operator*=(GroupList5 &x);//tested
	GroupList5 &operator-=(GroupList5 &x);//tested
	GroupList5 operator+(const GroupList5 &x);//tested
	GroupList5 operator*(GroupList5 &x); // intersection//tested
	GroupList5 operator-(GroupList5 &x); // set difference//tested
	//GroupList5 operator-(); // complement not practical, 2^33554432 subsets
	int operator==(GroupList5 &x);//tested
	int operator!=(GroupList5 &x);//tested
	int operator<(GroupList5 &x);//tested
	int operator<=(GroupList5 &x);//tested
	int operator>(GroupList5 &x);//tested
	int operator>=(GroupList5 &x);//tested
	// accessors
	Group5 * GetFirstGroup(void);//tested
	Group5 * GetNextGroup(void);//tested
	Group5 * GetGroup(int x);//tested
	GroupList2 Get2x2(int x,int y);//tested
	GroupList3 Get3x3(int x,int y);//tested
	GroupList4 Get4x4(int x,int y);//tested
	GroupList5 * GetNext(void);//tested
	void SetNext(GroupList5 * NewNext);//tested
	void Add(Group5 &x);//tested
	int Delete(Group5 *x);//tested
	int Order(void);//tested
	// utilites
	void CloseAll(void);//tested
	void Sort(void);//tested
	void Clear(void);//tested
	void GenerateS2Conj(void);//tested
	void GenerateS3Conj(void);//tested
	void GenerateS4Conj(void);//tested
	void GenerateS5Conj(void);//tested
	void GenerateS5AConj(void);//tested
	void GenerateS5BConj(void);//tested
	void GenerateS5CConj(void);//tested
	void GenerateS5DConj(void);//tested
	char *Serialize(void);//tested
	char *SerializeNL(void);//tested
	int Contains(Group5 &x);//tested
	int HasDups(void);//tested
	void RmDups(void);//tested
	//void GenerateAll(void); // not practical, 2^33554432 subsets
protected:
	GroupList5 *Next;
	Group5 *Head;
	Group5 *Tail;
	int Count;
	Group5 *Current;
};

//enumerate the 2x2 general linear group (or some portion thereof) without storing it
//<5 the GLG is small enough that the storage isn't a critical factor, but enumeration is a convenience.
class GenerateGLG2: public Matrix2
{
public:
	//constructors
	GenerateGLG2();//tested
	GenerateGLG2(const GenerateGLG2 &x);//tested
	//type converter
	GenerateGLG2(Matrix2 &x);//tested
	//destructor
	~GenerateGLG2();//tested
	//operator overloads
	GenerateGLG2 &operator=(const GenerateGLG2 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int InUse[4];
	int RowValue[2];
};

//Same, but for all 2x2 matrices
class GenerateAll2: public Matrix2 
{
public:
	//constructors
	GenerateAll2();//tested
	GenerateAll2(const GenerateAll2 &x);//tested
	//type converter
	GenerateAll2(Matrix2 &x);//tested
	//destructor
	~GenerateAll2();
	//operator overloads
	GenerateAll2 &operator=(const GenerateAll2 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int RowValue[2];
};

//enumerate the 3x3 general linear group (or some portion thereof) without storing it
//<5 the GLG is small enough that the storage isn't a critical factor, but enumeration is a convenience.
class GenerateGLG3: public Matrix3
{
public:
	//constructors
	GenerateGLG3();//tested
	GenerateGLG3(const GenerateGLG3 &x);//tested
	//type converter
	GenerateGLG3(Matrix3 &x);//tested
	//destructor
	~GenerateGLG3();//tested
	//operator overloads
	GenerateGLG3 &operator=(const GenerateGLG3 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int InUse[8];
	int RowValue[3];
};

//Same, but for all 3x3 matrices
class GenerateAll3: public Matrix3 
{
public:
	//constructors
	GenerateAll3();//tested
	GenerateAll3(const GenerateAll3 &x);//tested
	//type converter
	GenerateAll3(Matrix3 &x);//tested
	//destructor
	~GenerateAll3();
	//operator overloads
	GenerateAll3 &operator=(const GenerateAll3 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int RowValue[3];
};

//enumerate the 4x4 general linear group (or some portion thereof) without storing it
//<5 the GLG is small enough that the storage isn't a critical factor, but enumeration is a convenience.
class GenerateGLG4: public Matrix4
{
public:
	//constructors
	GenerateGLG4();//tested
	GenerateGLG4(const GenerateGLG4 &x);//tested
	//type converter
	GenerateGLG4(Matrix4 &x);//tested
	//destructor
	~GenerateGLG4();//tested
	//operator overloads
	GenerateGLG4 &operator=(const GenerateGLG4 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int InUse[16];
	int RowValue[4];
};

//Same, but for all 4x4 matrices
class GenerateAll4: public Matrix4 
{
public:
	//constructors
	GenerateAll4();//tested
	GenerateAll4(const GenerateAll4 &x);//tested
	//type converter
	GenerateAll4(Matrix4 &x);//tested
	//destructor
	~GenerateAll4();
	//operator overloads
	GenerateAll4 &operator=(const GenerateAll4 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int RowValue[4];
};

//enumerate the 5x5 general linear group (or some portion thereof) without storing it
//<5 the GLG is small enough that the storage isn't a critical factor.
class GenerateGLG5: public Matrix5
{
public:
	//constructors
	GenerateGLG5();//tested
	GenerateGLG5(const GenerateGLG5 &x);//tested
	//type converter
	GenerateGLG5(Matrix5 &x);//tested
	//destructor
	~GenerateGLG5();//tested
	//operator overloads
	GenerateGLG5 &operator=(const GenerateGLG5 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int InUse[32];
	int RowValue[5];
};

//Same, but for all 5x5 matrices
class GenerateAll5: public Matrix5 
{
public:
	//constructors
	GenerateAll5();//tested
	GenerateAll5(const GenerateAll5 &x);//tested
	//type converter
	GenerateAll5(Matrix5 &x);//tested
	//destructor
	~GenerateAll5();
	//operator overloads
	GenerateAll5 &operator=(const GenerateAll5 &x);//tested
	//accessors
	//utilities
	int First();//tested
	int Next();//tested
	int First(int x);//tested
	int Next(int x);//tested
protected:
	int RowValue[5];
};


#endif