getLMN := function(a,b,c)
   l := Order(a);
   m := Order(b);
   n := Order(c);
   return [l,m,n];
   end function; 

getParity := function(lmn);
   L := [];
   for j := 1 to #lmn do Append(~L,lmn[j] mod 2); end for;
   return L;
   end function; 


getLaMuNu := function(lmn)
   L := [];
   for j := 1 to #lmn do Append(~L,lmn[j] div 2); end for;
   return L;
   end function; 

getRPQ := function(a,b,c,G)
   return [sub<G|a>,sub<G|b>, sub<G|c>];
   end function; 


OvalRotpqr := function(a,b,c)
   lmn := getLMN(a,b,c);
   par := getParity(lmn);
   lamunu := getLaMuNu(lmn);
   la := lamunu[1];
   mu := lamunu[2];
   nu := lamunu[3]; 

   al := a^(la+par[1]);
   bm := b^(mu+par[2]);
   cn := c^(nu+par[3]);
   ali := al^(-1);
   bmi := bm^(-1);
   cni := cn^(-1);

   if par eq [1,1,1]
      then 
       hp := al*bm*cn;
       hq := bm*cn*al;
       hr := cn*al*bm;
      end if;
   if par eq [1,1,0]
      then 
       hp := al*bm*cn*bmi*ali*cn;
       hq := bm*cn*bmi*ali*cn*al;
       hr := cn*bmi*ali*cn*al*bm;
      end if;
   if par eq [0,1,0]
      then 
       hp := al*cn;
       hq := bm*cn*bmi*al;
       hr := cn*bmi*al*bm;
      end if;
   if par eq [0,0,0]
      then 
       hp := al*cn;
       hq := bm*al;
       hr := cn*bm;
      end if;
   return [hp,hq,hr];
   end function; 
   


Ovalspqr := function(a,b,c,G)
   lmn := getLMN(a,b,c);
   par := getParity(lmn);
   lamunu := getLaMuNu(lmn);
   la := lamunu[1];
   mu := lamunu[2];
   nu := lamunu[3]; 

   al := a^(la+par[1]);
   bm := b^(mu+par[2]);
   cn := c^(nu+par[3]);
   ali := al^(-1);
   bmi := bm^(-1);
   cni := cn^(-1);


   R := sub<G|a>;
   P := sub<G|b>;
   Q := sub<G|c>;

   hpqr := OvalRotpqr(a,b,c);
   hp := hpqr[1];
   hq := hpqr[2];
   hr := hpqr[3];

   
   if par eq [1,1,1]
      then 
        spatp := [R,P,Q];
        spatq := [P,Q,R];
        spatr := [Q,R,P];
        epatp := [Id(G),al,al*bm];
        epatq := [Id(G),bm,bm*cn];
        epatr := [Id(G),cn,cn*al];
      end if;

   if par eq [1,1,0]
      then 
        spatp := [R,P,Q,P,R,Q];
        spatq := [P,Q,P,R,Q,R];
        spatr := [Q,P,R,Q,R,P];
        epatp := [Id(G),al,al*bm,al*bm*cn,
                 al*bm*cn*bmi,al*bm*cn*bmi*ali];
        epatq := [Id(G),bm,bm*cn,bm*cn*bmi,
                 bm*cn*bmi*ali,bm*cn*bmi*ali*cn];
        epatr := [Id(G),cn,cn*bmi,cn*bmi*ali,
                 cn*bmi*ali*cn,cn*bmi*ali*cn*al];
      end if;

   if par eq [0,1,0]
      then 
        spatp := [R,Q];
        spatq := [P,Q,P,R];
        spatr := [Q,P,R,P];;
        epatp := [Id(G),al];
        epatq := [Id(G),bm, bm*cn,bm*cn*bmi];
        epatr := [Id(G),cn,cn*bmi,cn*bmi*al];
      end if;

   if par eq [0,0,0]
      then 
        spatp := [R,Q];
        spatq := [P,R];
        spatr := [Q,P];
        epatp := [Id(G),al];
        epatq := [Id(G),bm];
        epatr := [Id(G),cn];
      end if;
    
    Op := [* *];
    for i := 0 to Order(hp)-1 do
    for j:= 1 to #spatp do
        Append(~Op,[* hp^i*epatp[j],spatp[j] *]);
        end for;
        end for; 
    Oq := [* *];
    for i := 0 to Order(hq)-1 do
    for j:= 1 to #spatq do
        Append(~Oq,[* hq^i*epatq[j],spatq[j] *]);
        end for;
        end for; 
    Or := [* *];
    for i := 0 to Order(hr)-1 do
    for j:= 1 to #spatq do
        Append(~Or,[* hr^i*epatr[j],spatr[j] *]);
        end for;
        end for; 
   return [Op,Oq,Or];
   end function; 



OvalPoints := function(oval,G)
   L := [];
   for j := 1 to #oval do Append(~L,G!oval[j][1]*oval[j][2]); end for;
   return L;
   end function; 

MoveOval := function(oval,h,G)
   L := [* *];
   for j := 1 to #oval do Append(~L,[* G!h*oval[j][1],oval[j][2] *]); end for;
   return L;
   end function;

OvalIntersection:= function(O1,O2,G)
   pO1 := OvalPoints(O1,G);
   pO2 := OvalPoints(O2,G);
   Oint :=[];
   for i:=1 to #pO1 do
      for j:=1 to #pO2 do
          if pO1[i] eq pO2[j] 
            then 
             Append(~Oint,pO1[i]);
             break;
             end if;
          end for;
       end for;
   return Oint;  
   end function; 


  OvalIntersectionPattern:= function(O1,O2,stP,G)
    v := stP.1;
    L := [];
    for i:= 0 to Order(v)-1 do
         O3 := MoveOval(O2,v^i,G);
         Append(~L,#OvalIntersection(O1,O3,G));
         end for;
    return(L); 
    end function;