# snow
# n:=12;; g:=Group((1,3,5,7,9,11)*(2,4,6,8,10,12),(3,4)*(2,5)*(1,6)*(7,12)*(8,11)*(9,10));;  

# K5
# n:=5;; g:=Group((1,2,3,4,5),(1,2));;

# K4
# n:=4;; g:=Group((1,2,3,4),(1,2));; 

# K4 2 subdivisions
# n:=16;; g:=Group((1,2,3,4)*(5,6,7,8)*(9,10,11,12)*(13,14,15,16),(1,2)*(5,9)*(6,13)*(8,16)*(10,15)*(12,14));; 

h:=Group((n+1,n+2));;  
s:=[1..n+2];;
d:=DirectProduct(g,h);;
c:=ConjugacyClassesSubgroups(d);;
# l:=LatticeSubgroups( d );
# List(c,x->AsList(x));
subgroups:=[];;
for x in c do
#  Print(AsList(x),"\n\n");
  subgroups:=Concatenation(subgroups,AsList(x));
od; 
# Print(subgroups);

act:=function(sp,actor) 
 local a;
 sp:=Permuted(sp,actor);
 a:=Concatenation([1..n],[n+1,n+2]);
 a:=Permuted(a,actor);
# Print(actor,a);
 if a[n+1]<>n+1 then
    sp:=List(sp,x -> -x);
 fi;
 return sp;
end;;

###########################################

fixes:=function(sp,gr)
 local b,c;
 b:=[];
# Print(sp,AsList(gr));
 for c in AsList(gr) do
#     Print(act(sp,c),"!");
     Add(b,act(sp,c));
 od;
 return Unique(b);
end;;

###########################################

maximal:=function(sp,si)
 local c;
 for c in subgroups do
     if Length(fixes(sp,c))=1 and Length(AsList(c))>si then
       return 0;
     fi;
 od;
 return 1;
end;;

###########################################

# act([1,2,3],(1,2)(4,5));
# act([1,2,3],(1,2));
# Length(fixes([1,2,3],subgroups[6]));

# a:=Representative(c[6]);
# List(c,x->AsList(Representative(x)));
# aa:=GeneratorsOfGroup(a);
# OrbitPerms(aa,2);

db:=1;;
typs:=[];;
for x in c do
ig:=0;
for xx in AsList(x) do
  a:=AsList(xx);
#  Print(a,"\n");
  b:=Orbit(xx,s,Permuted);
#  Print(b,"\n");
  func:=[1..n];
  for i in [2..Length(b)] do
    actor:=b[i];
    if actor[n+1]=n+1 then
       sig:=1;
    else
       sig:=-1;
    fi;
    for j in [1..n] do
      mi:=j;
      ma:=actor[j];
      if AbsInt(func[j]) > AbsInt(func[actor[j]]) then
         mi:=actor[j];
	 ma:=j;
      fi;
      mav:=func[ma];
      miv:=func[mi]; 
      chv:=sig*miv;     
      if mav = -chv then
         chv := 0;
      fi;
      for k in [1..n] do
         if func[k]=mav then
	    func[k]:=chv;
	 fi;
	 if func[k]=miv and chv=0 then
	    func[k]:=chv;
	 fi;
      od;	 
    od;
  od;
  m:=maximal(func,Length(a));
  if m=1 then
    if ig=0 then
       Print("\n",db,"\n");
    fi;
    ig:=1;
    Print(func," ",xx," ",IdGroup(xx), "\n");
  fi;
od;
if ig=1 then
  db:=db+1;
  Add(typs,x);
fi;
od;
db:=db-1;;

subgr:=function(cc1,cc2)
  local gr,hr,cc2l,d;
  cc2l:=AsList(cc2);
  gr:=Representative(cc1);
  d:=0;
  for hr in cc2l do
    if IsSubset(hr,gr) then
      d:=1;
    fi;
  od; 
  return d;
end;;

Print("\nSubgroup structure\n");
cols:=[[0..db]];;
db:=0;;
for cc1 in typs do
  db:=db+1;
  row:=[db];
  for cc2 in typs do
      Add(row,subgr(cc1,cc2));
  od; 
  Add(cols,row);    
od;
Display(cols);

PrintTo("types.gap","n:=",n,";\ntypes:=",typs,";");