MODULE Refine;

(*
   This interface contain essentially procedures for support the programs
   of refiment of tetrahedra.
*)

IMPORT Triangulation, Octf, Squared, R3, Wr, Stdio, Thread;

FROM Stdio IMPORT stderr;

FROM Triangulation IMPORT Pair, Glue, MakeTetraTopo, OrgV,
     MakeFacetEdge, MakeVertex, SetOrg, Vertex;

FROM Octf IMPORT Clock, Enext, Enext_1, Spin, SetEnext, SetFace, SetFnext,
     SetEdgeAll, Onext, Fnext;

PROCEDURE MakeTetra(order: CARDINAL; net: BOOLEAN := FALSE) : Corner =
  VAR c : Corner;
  BEGIN
    CASE order OF 
    | 1   => RETURN MakeTetra1(net);
    | 2   => RETURN MakeTetra2(net); 
    | 3   => RETURN MakeTetra3(net);
    | 4   => RETURN MakeTetra4(net);
    | 5   => RETURN MakeTetra5(net);
    ELSE
      RETURN c;
    END
  END MakeTetra;

PROCEDURE MakeTriang(order: CARDINAL): REF ARRAY OF TRI =
  VAR t : REF ARRAY OF TRI;
  BEGIN
    CASE order OF 
    | 1   => RETURN MakeTriang1();
    | 2   => RETURN MakeTriang2(); 
    | 3   => RETURN MakeTriang3();
    | 4   => RETURN MakeTriang4();
    | 5   => RETURN MakeTriang5();
    ELSE
      RETURN t;
    END
  END MakeTriang;

PROCEDURE MakeLevTe(order: CARDINAL) : Pack =
  VAR p : Pack;
  BEGIN
    CASE order OF 
    | 1   => RETURN MakeLevTe1();
    | 2   => RETURN MakeLevTe2(); 
    | 3   => RETURN MakeLevTe3();
    | 4   => RETURN MakeLevTe4();
    | 5   => RETURN MakeLevTe5();
    ELSE
      RETURN p;
    END
  END MakeLevTe;

PROCEDURE MakeRowTe(order: CARDINAL) : Free =
  VAR f : Free;
  BEGIN
    CASE order OF 
    | 1   => RETURN MakeRowTe1();
    | 2   => RETURN MakeRowTe2(); 
    | 3   => RETURN MakeRowTe3();
    | 4   => RETURN MakeRowTe4();
    | 5   => RETURN MakeRowTe5();
    ELSE
      RETURN f;
    END
  END MakeRowTe;

PROCEDURE MakeRowTriang(order: CARDINAL) : REF ARRAY OF TRI =
  VAR t : REF ARRAY OF TRI;
  BEGIN
    CASE order OF 
    | 1   => RETURN MakeRowTriang1();
    | 2   => RETURN MakeRowTriang2(); 
    | 3   => RETURN MakeRowTriang3();
    | 4   => RETURN MakeRowTriang4();
    | 5   => RETURN MakeRowTriang5();
    ELSE
      RETURN t;
    END
  END MakeRowTriang;

PROCEDURE MakeGluea(order: CARDINAL) : Pair =
  BEGIN
    CASE order OF 
    | 1   => RETURN GlueRefineTetra(0,1,1);
    | 2   => RETURN GlueRefineTetra(0,1,2);
    | 3   => RETURN GlueRefineTetra(0,1,3);
    | 4   => RETURN GlueRefineTetra(0,1,4);
    | 5   => RETURN GlueRefineTetra(0,1,5);
    ELSE
      RETURN Triangulation.MakeFacetEdge();
    END
  END MakeGluea;

PROCEDURE MakeGlueb(order: CARDINAL) : Pair =
  BEGIN
    CASE order OF 
    | 1   => RETURN GlueRefineTetra(1,0,1);
    | 2   => RETURN GlueRefineTetra(1,0,2);
    | 3   => RETURN GlueRefineTetra(1,0,3);
    | 4   => RETURN GlueRefineTetra(1,0,4);
    | 5   => RETURN GlueRefineTetra(1,0,5);
    ELSE
      RETURN Triangulation.MakeFacetEdge();
    END
  END MakeGlueb;

PROCEDURE MakeGluec(order: CARDINAL) : Pair =
  BEGIN
    CASE order OF 
    | 1   => RETURN GlueRefineTetra(3,2,1);
    | 2   => RETURN GlueRefineTetra(3,2,2);
    | 3   => RETURN GlueRefineTetra(3,2,3);
    | 4   => RETURN GlueRefineTetra(3,2,4);
    | 5   => RETURN GlueRefineTetra(3,2,5);
    ELSE
      RETURN Triangulation.MakeFacetEdge();
    END
  END MakeGluec;

PROCEDURE MakeGlued(order: CARDINAL) : Pair =
  BEGIN
    CASE order OF 
    | 1   => RETURN GlueRefineTetra(2,3,1);
    | 2   => RETURN GlueRefineTetra(2,3,2);
    | 3   => RETURN GlueRefineTetra(2,3,3);
    | 4   => RETURN GlueRefineTetra(2,3,4);
    | 5   => RETURN GlueRefineTetra(2,3,5);
    ELSE
      RETURN Triangulation.MakeFacetEdge();
    END
  END MakeGlued;

PROCEDURE MakeTetra1(net: BOOLEAN := FALSE) : Corner =
  VAR c : Corner;
  BEGIN
    c.right := NEW(REF PAIR,1);
    c.left  := NEW(REF PAIR,1);
    c.front := NEW(REF PAIR,1);
    c.back  := NEW(REF PAIR,1);
    WITH
      a = MakeLevTe1()
    DO
      c.right[0] := a.corner.right[0];
      c.left [0] := a.corner.left [0];
      c.front[0] := a.corner.front[0];
      c.back [0] := a.corner.back [0];
      (* new extensions *)
      SetLackVertices(1,c);
      IF net THEN SetGrade(1,c) END;
      RETURN c;    
    END
  END MakeTetra1;

PROCEDURE MakeTetra2(net: BOOLEAN := FALSE) : Corner =
  VAR c : Corner;
  BEGIN
    c.right := NEW(REF PAIR,4);
    c.left  := NEW(REF PAIR,4);
    c.front := NEW(REF PAIR,4);
    c.back  := NEW(REF PAIR,4);
    WITH
      a = MakeTetra1(),
      b = MakeLevTe2()
    DO
      EVAL Glue(Spin(b.side.upper[0]), a.back[0],1);
      HideFace      (b.side.upper[0]);

      FOR j := 0 TO 3 DO
        c.back[j] := b.corner.back[j];
      END;

      c.right[0] := a.right[0];
      c.left [0] := a.left [0];
      c.front[0] := a.front[0];

      FOR i := 1 TO 3 DO
        c.right[i] := b.corner.right[i-1];
        c.left [i] := b.corner.left [i-1];
        c.front[i] := b.corner.front[i-1];
      END;
      (* new extensions *)
      SetLackVertices(2,c);
      IF net THEN SetGrade(2,c) END;
      RETURN  c;
    END
  END MakeTetra2;

PROCEDURE MakeTetra3(net: BOOLEAN := FALSE) : Corner =
  VAR d : Corner;
  BEGIN
    d.right := NEW(REF PAIR,9);
    d.left  := NEW(REF PAIR,9);
    d.front := NEW(REF PAIR,9);
    d.back  := NEW(REF PAIR,9);
    WITH
      a  = MakeTetra2(),
      c  = MakeLevTe3()
    DO
      (*
        Tetra-2 with Level-3:
        
        a.back[0]=T with c.upper[0]=O
        a.back[1]=T with c.upper[1]=O
        a.back[2]=O with c.upper[2]=T
        a.back[3]=T with c.upper[3]=O
      *)
      <* ASSERT NUMBER(a.back^) = NUMBER(c.side.upper^) *>
      
      EVAL    Glue(Spin (a.back[0]), c.side.upper[0], 1, TRUE);
      HideFace          (a.back[0]);
     
      EVAL    Glue(Spin (a.back[1]), c.side.upper[1], 1, TRUE);
      HideFace          (a.back[1]);

      EVAL    Glue(Clock(a.back[2]), c.side.upper[2], 1, TRUE);
      HideFace          (a.back[2]);

         EVAL Glue(Spin (a.back[3]), c.side.upper[3], 1, TRUE);
      HideFace          (a.back[3]);

      FOR j := 0 TO 8 DO
        d.back[j] := c.corner.back[j];
      END;

      FOR i := 0 TO 3 DO
        d.right[i] := a.right[i];
        d.left [i] := a.left [i];
        d.front[i] := a.front[i];
      END;

      FOR i := 4 TO 8 DO
        d.right[i] := c.corner.right[i-4];
        d.left [i] := c.corner.left [i-4];
        d.front[i] := c.corner.front[i-4];
      END;
      (* new extensions *)
      SetLackVertices(3,d);
      IF net THEN SetGrade(3,d) END;
      RETURN d;
    END
  END MakeTetra3;

PROCEDURE MakeTetra4(net: BOOLEAN := FALSE) : Corner =
  VAR e : Corner;
  BEGIN
    e.right := NEW(REF PAIR,16);
    e.left  := NEW(REF PAIR,16);
    e.front := NEW(REF PAIR,16);
    e.back  := NEW(REF PAIR,16);
    WITH
      a  = MakeTetra3(),
      d  = MakeLevTe4()
    DO
      (* gluing Tetra-3 with upper Level-4 *)
      <* ASSERT NUMBER(a.back^) = NUMBER(d.side.upper^) *>

      EVAL    Glue(Spin (a.back[0]), d.side.upper[0], 1, TRUE);
      HideFace          (a.back[0]);
     
      EVAL    Glue(Spin (a.back[1]), d.side.upper[1], 1, TRUE);
      HideFace          (a.back[1]);

      EVAL    Glue(Clock(a.back[2]), d.side.upper[2], 1, TRUE);
      HideFace          (a.back[2]);

         EVAL Glue(Spin (a.back[3]), d.side.upper[3], 1, TRUE);
      HideFace          (a.back[3]);

      EVAL    Glue(Spin (a.back[4]), d.side.upper[4], 1, TRUE);
      HideFace          (a.back[4]);
           
      EVAL    Glue(Clock(a.back[5]), d.side.upper[5], 1, TRUE);
      HideFace          (a.back[5]);

      EVAL    Glue(Spin (a.back[6]), d.side.upper[6], 1, TRUE);
      HideFace          (a.back[6]);
          
       EVAL   Glue(Clock(a.back[7]), d.side.upper[7], 1, TRUE);
      HideFace          (a.back[7]);

      EVAL    Glue(Spin (a.back[8]), d.side.upper[8], 1, TRUE);
      HideFace          (a.back[8]);

      FOR j := 0 TO 15 DO
        e.back[j] := d.corner.back[j];
      END;

      FOR i := 0 TO 8 DO
        e.right[i] := a.right[i];
        e.left [i] := a.left [i];
        e.front[i] := a.front[i];
      END;

      FOR i := 9 TO 15 DO
        e.right[i] := d.corner.right[i-9];
        e.left [i] := d.corner.left [i-9];
        e.front[i] := d.corner.front[i-9];
      END;
      (* new extensions *)
      SetLackVertices(4,e);
      IF net THEN SetGrade(4,e) END;
      RETURN e;
    END
  END MakeTetra4;

PROCEDURE MakeTetra5(net: BOOLEAN := FALSE) : Corner =
  VAR f : Corner;
  BEGIN
    f.right := NEW(REF PAIR,25);
    f.left  := NEW(REF PAIR,25);
    f.front := NEW(REF PAIR,25);
    f.back  := NEW(REF PAIR,25);
    WITH
      a = MakeTetra4(),
      e = MakeLevTe5()
    DO
      (* gluing Tetra-4 with upper Level-5 *)
      <* ASSERT NUMBER(a.back^) = NUMBER(e.side.upper^) *>

      (* sixteen glues *)

      (* upper 
      s.upper[0 ] := r2.octah[0,5];
      s.upper[1 ] := r3.octah[0,5];              
      s.upper[2 ] := r3.tetra[3,2];       
      s.upper[3 ] := r3.octah[1,5];
      s.upper[4 ] := r4.octah[0,5];
      s.upper[5 ] := r4.tetra[5,2];
      s.upper[6 ] := r4.octah[1,5];
      s.upper[7 ] := r4.tetra[4,2];
      s.upper[8 ] := r4.octah[2,5];
      s.upper[9 ] := r5.octah[0,5];
      s.upper[10] := r5.tetra[7,2];
      s.upper[11] := r5.octah[1,5];
      s.upper[12] := r5.tetra[5,2];
      s.upper[13] := r5.octah[2,5];
      s.upper[14] := r5.tetra[6,2];
      s.upper[15] := r5.octah[3,5];
      *)

      (* lower 
      s.lower[0 ] := r1.tetra[0,2];
      s.lower[1 ] := r2.tetra[0,2];              
      s.lower[2 ] := r2.octah[3,3];       
      s.lower[3 ] := r2.tetra[1,2];
      s.lower[4 ] := r3.tetra[0,2];
      s.lower[5 ] := r3.octah[5,3];
      s.lower[6 ] := r3.tetra[1,2];
      s.lower[7 ] := r3.octah[4,3];
      s.lower[8 ] := r3.tetra[2,2];     
      s.lower[9 ] := r4.tetra[0,2];
      s.lower[10] := r4.octah[0,3];              
      s.lower[11] := r4.tetra[1,2];       
      s.lower[12] := r4.octah[1,3];
      s.lower[13] := r4.tetra[2,2];
      s.lower[14] := r4.octah[2,3];
      s.lower[15] := r4.tetra[3,2];               
      *)

      EVAL    Glue(Spin(a.back[0]),  e.side.upper[0], 1, TRUE);
      HideFace         (a.back[0]);

      EVAL    Glue(Spin(a.back[1]),  e.side.upper[1], 1, TRUE);
      HideFace         (a.back[1]);
 
      EVAL    Glue(Clock(a.back[2]), e.side.upper[2], 1, TRUE);
      HideFace          (a.back[2]);

      EVAL    Glue(Spin(a.back[3]),  e.side.upper[3], 1, TRUE);
      HideFace         (a.back[3]);
     
      EVAL    Glue(Spin(a.back[4]),  e.side.upper[4], 1, TRUE);
      HideFace         (a.back[4]);
     
      EVAL    Glue(Clock(a.back[5]), e.side.upper[5], 1, TRUE);
      HideFace          (a.back[5]);     

      EVAL    Glue(Spin(a.back[6]),  e.side.upper[6], 1, TRUE);
      HideFace         (a.back[6]);

      EVAL    Glue(Clock(a.back[7]), e.side.upper[7], 1, TRUE);
      HideFace          (a.back[7]);
     
      EVAL    Glue(Spin(a.back[8]),  e.side.upper[8], 1, TRUE);
      HideFace         (a.back[8]);     

      EVAL    Glue(Spin(a.back[9]),  e.side.upper[9], 1, TRUE);
      HideFace         (a.back[9]);

      EVAL    Glue(Clock(a.back[10]), e.side.upper[10], 1, TRUE);
      HideFace          (a.back[10]);

      EVAL    Glue(Spin(a.back[11]),  e.side.upper[11], 1, TRUE);
      HideFace         (a.back[11]);

      EVAL    Glue(Clock(a.back[12]), e.side.upper[12], 1, TRUE);
      HideFace          (a.back[12]);   

      EVAL    Glue(Spin(a.back[13]),  e.side.upper[13], 1, TRUE);
      HideFace         (a.back[13]);

      EVAL    Glue(Clock(a.back[14]), e.side.upper[14], 1, TRUE);
      HideFace          (a.back[14]);
     
      EVAL    Glue(Spin(a.back[15]),  e.side.upper[15], 1, TRUE);
      HideFace         (a.back[15]);

      FOR j := 0 TO 24 DO
        f.back[j] := e.corner.back[j];
      END;

      FOR i := 0 TO 15 DO
        f.right[i] := a.right[i];
        f.left [i] := a.left [i];
        f.front[i] := a.front[i];
      END;

      FOR i := 16 TO 24 DO
        f.right[i] := e.corner.right[i-16];
        f.left [i] := e.corner.left [i-16];
        f.front[i] := e.corner.front[i-16];
      END;
      (* new extensions *)
      SetLackVertices(5,f);
      IF net THEN SetGrade(5,f) END;
      RETURN f;
    END
  END MakeTetra5;  

(* Procedure for builds triangles *)

PROCEDURE MakeTriang1() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 1);
  BEGIN
    WITH
      t = MakeTriangle()
    DO
      r[0] := t;     
      RETURN r;
    END
  END MakeTriang1;

PROCEDURE MakeTriang2() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 4);
  BEGIN
    WITH
      t = MakeTriang1(),
      p = MakeRowTriang2()
    DO
      SetFnext  (t[0][0], Clock(p[1][0]));
      SetEdgeAll(t[0][0], t[0][0].facetedge.edge);

      SetOrgCycle(t[0][0],        OrgV(t[0][0]));
      SetOrgCycle(Clock(t[0][0]), OrgV(Clock(t[0][0])));

      FOR j := 0 TO 2 DO
        r[0][j] := t[0][j];
      END;

      FOR k := 1 TO 3 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k-1][i];
        END
      END
    END;
    RETURN r;
  END MakeTriang2;

PROCEDURE MakeTriang3() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 9);
  BEGIN
    WITH
      t = MakeTriang2(),
      p = MakeRowTriang3()
    DO
      SetFnext  (t[1][0], Clock(p[1][0]));
      SetFnext  (t[3][0], Clock(p[3][0]));
      SetEdgeAll(t[1][0], t[1][0].facetedge.edge);
      SetEdgeAll(t[3][0], t[3][0].facetedge.edge);

      SetOrgCycle(t[1][0],        OrgV(t[1][0]));
      SetOrgCycle(t[3][0],        OrgV(t[3][0]));
      SetOrgCycle(Clock(t[3][0]), OrgV(Clock(t[3][0])));
    
      FOR l := 0 TO 3 DO
        FOR j := 0 TO 2 DO 
          r[l][j] := t[l][j];
        END
      END;

      FOR k := 4 TO 8 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k-4][i];
        END
      END
    END;
    RETURN r;
  END MakeTriang3;

PROCEDURE MakeTriang4() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 16);
  BEGIN
    WITH
      t = MakeTriang3(),
      p = MakeRowTriang4()
    DO
      SetFnext  (t[4][0], Clock(p[1][0]));
      SetFnext  (t[6][0], Clock(p[3][0]));
      SetFnext  (t[8][0], Clock(p[5][0]));

      SetEdgeAll(t[4][0], t[4][0].facetedge.edge);
      SetEdgeAll(t[6][0], t[6][0].facetedge.edge);
      SetEdgeAll(t[8][0], t[8][0].facetedge.edge);

      SetOrgCycle(t[4][0],        OrgV(t[4][0]));
      SetOrgCycle(t[6][0],        OrgV(t[6][0]));
      SetOrgCycle(t[8][0],        OrgV(t[8][0]));
      SetOrgCycle(Clock(t[8][0]), OrgV(Clock(t[8][0])));
    
      FOR l := 0 TO 8 DO
        FOR j := 0 TO 2 DO 
          r[l][j] := t[l][j];
        END
      END;

      FOR k := 9 TO 15 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k-9][i];
        END
      END
    END;
    RETURN r;
  END MakeTriang4;

PROCEDURE MakeTriang5() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 25);
  BEGIN
    WITH
      t = MakeTriang4(),
      p = MakeRowTriang5()
    DO
      SetFnext  (t[9 ][0], Clock(p[1][0]));
      SetFnext  (t[11][0], Clock(p[3][0]));
      SetFnext  (t[13][0], Clock(p[5][0]));
      SetFnext  (t[15][0], Clock(p[7][0]));

      SetEdgeAll(t[9 ][0], t[9 ][0].facetedge.edge);
      SetEdgeAll(t[11][0], t[11][0].facetedge.edge);
      SetEdgeAll(t[13][0], t[13][0].facetedge.edge);
      SetEdgeAll(t[15][0], t[15][0].facetedge.edge);

      SetOrgCycle(t[9 ][0],        OrgV(t[9 ][0]));
      SetOrgCycle(t[11][0],        OrgV(t[11][0]));
      SetOrgCycle(t[13][0],        OrgV(t[13][0]));
      SetOrgCycle(t[15][0],        OrgV(t[15][0]));
      SetOrgCycle(Clock(t[15][0]), OrgV(Clock(t[15][0])));

      FOR l := 0 TO 15 DO
        FOR j := 0 TO 2 DO 
          r[l][j] := t[l][j];
        END
      END;

      FOR k := 16 TO 24 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k-16][i];
        END
      END
    END;
    RETURN r;
  END MakeTriang5;

PROCEDURE MakeLevTe1() : Pack = 
  VAR
    s : Side;
    c : Corner;
  BEGIN
    (* allocating memory *)
    s.lower := NEW(REF PAIR,1);

    c.right := NEW(REF PAIR,1);
    c.left  := NEW(REF PAIR,1);
    c.front := NEW(REF PAIR,1);
    c.back  := NEW(REF PAIR,1);
    
    WITH
      r1 = MakeRowTe1()
    DO
      (* computing side information *)
      s.lower[0] := r1.tetra[0,2];

      (* computing corner information *)
      c.right[0] := r1.tetra[0,0];
      c.left [0] := r1.tetra[0,1];
      c.front[0] := r1.tetra[0,3];
      FOR i := 0 TO 0 DO
        c.back [i] := s.lower[i];
      END;
      
      RETURN Pack{s,c};

      (* return the base of one tetrahedron

                         /\
                        /  \
                       /____\
      *)
    END
  END MakeLevTe1;

PROCEDURE MakeLevTe2() : Pack  =
  VAR
    s : Side;
    c : Corner;
  BEGIN
    (* side *)
    s.upper := NEW(REF PAIR,1);
    s.lower := NEW(REF PAIR,4);

    (* corner *)
    c.right := NEW(REF PAIR,3);
    c.left  := NEW(REF PAIR,3);
    c.front := NEW(REF PAIR,3);
    c.back  := NEW(REF PAIR,4);

    WITH
      r1 = MakeRowTe1(),
      r2 = MakeRowTe2()
    DO
      EVAL Glue(Spin(r2.octah[0,7]), Clock(Spin(r1.tetra[0,3])),1);
      HideFace(r2.octah[0,7]);

      (* computing side information *)
      s.upper[0] := r2.octah[0,5];

      s.lower[0] := r1.tetra[0,2];
      s.lower[1] := r2.tetra[0,2];
      s.lower[2] := r2.octah[0,3];
      s.lower[3] := r2.tetra[1,2];

      (* computing corner information *)

      c.right[0] := r1.tetra[0,0];
      c.right[1] := r2.octah[0,6];
      c.right[2] := r2.tetra[1,0];

      c.left [0] := r1.tetra[0,1];
      c.left [1] := r2.octah[0,4];
      c.left [2] := r2.tetra[0,1];

      c.front[0] := r2.tetra[0,3];
      c.front[1] := r2.octah[0,1];
      c.front[2] := r2.tetra[1,3];

      FOR i := 0 TO 3 DO
        c.back [i] := s.lower[i];
      END;
 
      RETURN Pack{s,c};

      (* return a single upper triangular face of the level-2 that will
         be glue with the single lower triangular face of the level-1.

		             /\              /\  
			    /  \            /  \
			   / 0  \          / 0  \
			  /------\         ------
			 / \ 2  / \
			/ 1 \  / 3 \
		       /_____\/_____\    
                                         			     
		           s.lower	   s.upper
      *)
    END
  END MakeLevTe2;

PROCEDURE MakeLevTe3() : Pack = 
  VAR
    s: Side;
    c: Corner;
  BEGIN
    (* side *)
    s.upper := NEW(REF PAIR,4);
    s.lower := NEW(REF PAIR,9);

    (* corner *)
    c.right := NEW(REF PAIR,5);
    c.left  := NEW(REF PAIR,5);
    c.front := NEW(REF PAIR,5);
    c.back  := NEW(REF PAIR,9);

    WITH
      r1 = MakeRowTe1(),
      r2 = MakeRowTe2(),
      r3 = MakeRowTe3()
    DO
      (* free pairs
         r3.tetra[3,3] =>  r2.octah[0,1]
         r3.octah[0,7] =>  r2.tetra[0,3]
         r3.octah[1,7] =>  r2.tetra[1,3]
         r2.octah[0,7] =>  r1.tetra[0,3]
      *) 
     
      EVAL Glue(Spin (r3.tetra[3,3]), r2.octah[0,1], 1);
      HideFace       (r3.tetra[3,3]);
      EVAL Glue(Clock(r3.octah[0,7]), r2.tetra[0,3], 1);
      HideFace       (r3.octah[0,7]);
      EVAL Glue(Clock(r3.octah[1,7]), r2.tetra[1,3], 1);
      HideFace       (r3.octah[1,7]);
      EVAL Glue(Clock(r2.octah[0,7]), r1.tetra[0,3], 1); 
      HideFace       (r2.octah[0,7]);

      (* computing side information *)
         (* upper *)
      s.upper[0] := r2.octah[0,5];               
      s.upper[1] := r3.octah[0,5];              
      s.upper[2] := r3.tetra[3,2];       
      s.upper[3] := r3.octah[1,5];

         (* lower *)
      s.lower[0] := r1.tetra[0,2];
      s.lower[1] := r2.tetra[0,2];
      s.lower[2] := r2.octah[0,3];
      s.lower[3] := r2.tetra[1,2];
      s.lower[4] := r3.tetra[0,2];
      s.lower[5] := r3.octah[0,3];
      s.lower[6] := r3.tetra[1,2];
      s.lower[7] := r3.octah[1,3];
      s.lower[8] := r3.tetra[2,2];

      (* computing corner information *)

      c.right[0] := r1.tetra[0,0];
      c.right[1] := r2.octah[0,6];
      c.right[2] := r2.tetra[1,0];
      c.right[3] := r3.octah[1,6];
      c.right[4] := r3.tetra[2,0];

      c.left [0] := r1.tetra[0,1];
      c.left [1] := r2.octah[0,4];
      c.left [2] := r2.tetra[0,1];
      c.left [3] := r3.octah[0,4];
      c.left [4] := r3.tetra[0,1];

      c.front[0] := r3.tetra[0,3];
      c.front[1] := r3.octah[0,1];
      c.front[2] := r3.tetra[1,3];
      c.front[3] := r3.octah[1,1];
      c.front[4] := r3.tetra[2,3];

      FOR i := 0 TO 8 DO
        c.back [i] := s.lower[i];
      END;
 
      RETURN Pack{s,c};

     (* return an array of (four) upper triangular faces of the level three
        that will be glue with the (four) lower triangular faces of the
        level two.

			     /\                     /\     
			    /  \                   /  \  
			   / 0  \                 / 0  \
			  /------\               /------\
			 / \ 2  / \             / \ 2  / \
			/ 1 \  / 3 \           / 1 \  / 3 \  
		       /_____\/_____\         /_____\/_____\    
                                             /  5  / \  7 / \
                                            /  \  /   \  /   \
                                           / 4  \/  6  \/  8  \
                                           --------------------
	
                           s.upper               s.lower
    *)
    END
  END MakeLevTe3;

PROCEDURE MakeLevTe4() : Pack = 
  VAR
    s: Side;
    c: Corner;
  BEGIN
    (* side *)
    s.upper := NEW(REF PAIR,9);
    s.lower := NEW(REF PAIR,16);
    (* corner *)
    c.right := NEW(REF PAIR,7);
    c.left  := NEW(REF PAIR,7);
    c.front := NEW(REF PAIR,7);
    c.back  := NEW(REF PAIR,16);
    WITH
      r1 = MakeRowTe1(),
      r2 = MakeRowTe2(),
      r3 = MakeRowTe3(),
      r4 = MakeRowTe4()
    DO
      (* r1 with r2 *)
      EVAL Glue(Clock(r2.octah[0,7]), r1.tetra[0,3], 1);
      HideFace       (r2.octah[0,7]);

      (* free pairs r2 with r3
         r3.tetra[3,3] =>  r2.octah[0,1]
         r3.octah[0,7] =>  r2.tetra[0,3]
         r3.octah[1,7] =>  r2.tetra[1,3]
         free pairs r2 with r1
         r2.octah[0,7] =>  r1.tetra[0,3]
      *) 

      (* r3 with r2 *)
      EVAL Glue(Spin (r3.tetra[3,3]), r2.octah[0,1], 1);
      HideFace       (r3.tetra[3,3]); 
      EVAL Glue(Clock(r3.octah[0,7]), r2.tetra[0,3], 1);
      HideFace       (r3.octah[0,7]);
      EVAL Glue(Clock(r3.octah[1,7]), r2.tetra[1,3], 1);
      HideFace       (r3.octah[1,7]);

      (* r4 with r3 *)
      (* free pairs r3 with r2
        
        r4.octah[0,7] =>  r3.tetra[0,3] 
        r4.tetra[5,3] =>  r3.octah[0,1]
        r4.octah[1,7] =>  r3.tetra[1,3]
        r4.tetra[1,3] =>  r3.octah[1,1]
        r4.octah[2,7] =>  r3.tetra[2,3]
      *) 

      EVAL    Glue(Spin (r4.tetra[5,3]), r3.octah[0,1], 1, TRUE);
      HideFace          (r4.tetra[5,3]);

      EVAL    Glue(Clock(r4.octah[0,7]), r3.tetra[0,3], 1, TRUE);
      HideFace          (r4.octah[0,7]);

      EVAL    Glue(Clock(r4.octah[1,7]), r3.tetra[1,3], 1, TRUE);
      HideFace          (r4.octah[1,7]);

      EVAL    Glue(Spin (r4.tetra[4,3]), r3.octah[1,1], 1, TRUE);
      HideFace          (r4.tetra[4,3]);

      EVAL    Glue(Clock(r4.octah[2,7]), r3.tetra[2,3], 1, TRUE);
      HideFace          (r4.octah[2,7]);

      (* upper *)
      s.upper[0] := r2.octah[0,5];
      s.upper[1] := r3.octah[0,5];              
      s.upper[2] := r3.tetra[3,2];       
      s.upper[3] := r3.octah[1,5];
      s.upper[4] := r4.octah[0,5];
      s.upper[5] := r4.tetra[5,2];
      s.upper[6] := r4.octah[1,5];
      s.upper[7] := r4.tetra[4,2];
      s.upper[8] := r4.octah[2,5];

      (* lower *)

      s.lower[0 ] := r1.tetra[0,2];
      s.lower[1 ] := r2.tetra[0,2];              
      s.lower[2 ] := r2.octah[0,3];       
      s.lower[3 ] := r2.tetra[1,2];
      s.lower[4 ] := r3.tetra[0,2];
      s.lower[5 ] := r3.octah[0,3];
      s.lower[6 ] := r3.tetra[1,2];
      s.lower[7 ] := r3.octah[1,3];
      s.lower[8 ] := r3.tetra[2,2];     
      s.lower[9 ] := r4.tetra[0,2];
      s.lower[10] := r4.octah[0,3];              
      s.lower[11] := r4.tetra[1,2];       
      s.lower[12] := r4.octah[1,3];
      s.lower[13] := r4.tetra[2,2];
      s.lower[14] := r4.octah[2,3];
      s.lower[15] := r4.tetra[3,2];

      (* computing corner information *)

      c.right[0] := r1.tetra[0,0];
      c.right[1] := r2.octah[0,6];
      c.right[2] := r2.tetra[1,0];
      c.right[3] := r3.octah[1,6];
      c.right[4] := r3.tetra[2,0];
      c.right[5] := r4.octah[2,6];
      c.right[6] := r4.tetra[3,0];

      c.left [0] := r1.tetra[0,1];
      c.left [1] := r2.octah[0,4];
      c.left [2] := r2.tetra[0,1];
      c.left [3] := r3.octah[0,4];
      c.left [4] := r3.tetra[0,1];
      c.left [5] := r4.octah[0,4];
      c.left [6] := r4.tetra[0,1];

      c.front[0] := r4.tetra[0,3];
      c.front[1] := r4.octah[0,1];
      c.front[2] := r4.tetra[1,3];
      c.front[3] := r4.octah[1,1];
      c.front[4] := r4.tetra[2,3];
      c.front[5] := r4.octah[2,1];
      c.front[6] := r4.tetra[3,3];

      FOR i := 0 TO 15 DO
        c.back [i] := s.lower[i];
      END;
 
      RETURN Pack{s,c};

      (* return an array of (nine) upper triangular faces of the level three
        that will be glue with the (nine) lower triangular faces of the
        level three.

			     /\                     /\     
			    /  \                   /  \  
			   / 0  \                 / 0  \
			  /------\               /------\
			 / \ 2  / \             / \ 2  / \
			/ 1 \  / 3 \           / 1 \  / 3 \  
		       /_____\/_____\         /_____\/_____\    
                      /\ 5  / \ 7  / \       /  5  / \  7 / \
                     /  \  /   \  /   \     /  \  /   \  /   \
                    / 4  \/ 6   \/ 8   \   / 4  \/  6  \/  8  \
                   /--------------------\  ---------------------
	          / \ 10 /\ 12  /\ 14 /  \
	         /   \  /  \   /  \  /    \
	        /  9  \/ 11 \ / 13 \/  15  \
	        ----------------------------
	
                           s.lower               s.upper
    *)
    END
  END MakeLevTe4;

PROCEDURE MakeLevTe5() : Pack = 
  VAR
    s: Side;
    c: Corner; 
  BEGIN
    (* side *)
    s.upper := NEW(REF PAIR,16);
    s.lower := NEW(REF PAIR,25);
    (* corner *)
    c.right := NEW(REF PAIR,9);
    c.left  := NEW(REF PAIR,9);
    c.front := NEW(REF PAIR,9);
    c.back  := NEW(REF PAIR,25);
    WITH
      r1 = MakeRowTe1(),
      r2 = MakeRowTe2(),
      r3 = MakeRowTe3(),
      r4 = MakeRowTe4(),
      r5 = MakeRowTe5()
    DO
      (* r1 with r2 *)
      EVAL Glue(Clock(r2.octah[0,7]), r1.tetra[0,3], 1);
      HideFace       (r2.octah[0,7]);

      (* free pairs r2 with r3
         r3.tetra[3,3] =>  r2.octah[0,1]
         r3.octah[0,7] =>  r2.tetra[0,3]
         r3.octah[1,7] =>  r2.tetra[1,3]
         free pairs r2 with r1
         r2.octah[0,7] =>  r1.tetra[0,3]
      *) 

      (* r3 with r2 *)
      EVAL Glue(Spin (r3.tetra[3,3]), r2.octah[0,1], 1);
      HideFace       (r3.tetra[3,3]); 
      EVAL Glue(Clock(r3.octah[0,7]), r2.tetra[0,3], 1);
      HideFace       (r3.octah[0,7]);
      EVAL Glue(Clock(r3.octah[1,7]), r2.tetra[1,3], 1);
      HideFace       (r3.octah[1,7]);

      (* r4 with r3 *)
      (* free pairs r3 with r2
        
        r4.octah[0,7] =>  r3.tetra[0,3] 
        r4.tetra[5,3] =>  r3.octah[0,1]
        r4.octah[1,7] =>  r3.tetra[1,3]
        r4.tetra[1,3] =>  r3.octah[1,1]
        r4.octah[2,7] =>  r3.tetra[2,3]
      *) 

      EVAL    Glue(Spin (r4.tetra[5,3]), r3.octah[0,1], 1, TRUE);
      HideFace          (r4.tetra[5,3]);

      EVAL    Glue(Clock(r4.octah[0,7]), r3.tetra[0,3], 1, TRUE);
      HideFace          (r4.octah[0,7]);

      EVAL    Glue(Clock(r4.octah[1,7]), r3.tetra[1,3], 1, TRUE);
      HideFace          (r4.octah[1,7]);

      EVAL    Glue(Spin (r4.tetra[4,3]), r3.octah[1,1], 1, TRUE);
      HideFace          (r4.tetra[4,3]);

      EVAL    Glue(Clock(r4.octah[2,7]), r3.tetra[2,3], 1, TRUE);
      HideFace          (r4.octah[2,7]);

      (* r4 with r5 *)

      EVAL    Glue(Spin (r5.tetra[7,3]), r4.octah[0,1], 1, TRUE);
      HideFace          (r5.tetra[7,3]);

      EVAL    Glue(Spin (r5.tetra[5,3]), r4.octah[1,1], 1, TRUE);
      HideFace          (r5.tetra[5,3]);
     
      EVAL    Glue(Clock(r5.octah[0,7]), r4.tetra[0,3], 1, TRUE); 
      HideFace          (r5.octah[0,7]);
     
      EVAL    Glue(Clock(r5.octah[1,7]), r4.tetra[1,3], 1, TRUE);
      HideFace          (r5.octah[1,7]);

      EVAL    Glue(Spin (r5.tetra[6,3]), r4.octah[2,1], 1, TRUE);
      HideFace          (r5.tetra[6,3]);
     
      EVAL    Glue(Clock(r5.octah[2,7]), r4.tetra[2,3], 1, TRUE);
      HideFace          (r5.octah[2,7]);

      EVAL    Glue(Clock(r5.octah[3,7]), r4.tetra[3,3], 1, TRUE);
      HideFace          (r5.octah[3,7]);

      (* computing corner information *)
      (* upper *)
      s.upper[0 ] := r2.octah[0,5];
      s.upper[1 ] := r3.octah[0,5];              
      s.upper[2 ] := r3.tetra[3,2];       
      s.upper[3 ] := r3.octah[1,5];
      s.upper[4 ] := r4.octah[0,5];
      s.upper[5 ] := r4.tetra[5,2];
      s.upper[6 ] := r4.octah[1,5];
      s.upper[7 ] := r4.tetra[4,2];
      s.upper[8 ] := r4.octah[2,5];
      s.upper[9 ] := r5.octah[0,5];
      s.upper[10] := r5.tetra[7,2];
      s.upper[11] := r5.octah[1,5];
      s.upper[12] := r5.tetra[5,2];
      s.upper[13] := r5.octah[2,5];
      s.upper[14] := r5.tetra[6,2];
      s.upper[15] := r5.octah[3,5];

      (* lower *)

      s.lower[0 ] := r1.tetra[0,2];
      s.lower[1 ] := r2.tetra[0,2];              
      s.lower[2 ] := r2.octah[0,3];       
      s.lower[3 ] := r2.tetra[1,2];
      s.lower[4 ] := r3.tetra[0,2];
      s.lower[5 ] := r3.octah[0,3];
      s.lower[6 ] := r3.tetra[1,2];
      s.lower[7 ] := r3.octah[1,3];
      s.lower[8 ] := r3.tetra[2,2];     
      s.lower[9 ] := r4.tetra[0,2];
      s.lower[10] := r4.octah[0,3];              
      s.lower[11] := r4.tetra[1,2];       
      s.lower[12] := r4.octah[1,3];
      s.lower[13] := r4.tetra[2,2];
      s.lower[14] := r4.octah[2,3];
      s.lower[15] := r4.tetra[3,2];

      s.lower[16] := r5.tetra[0,2];              
      s.lower[17] := r5.octah[0,3];       
      s.lower[18] := r5.tetra[1,2];
      s.lower[19] := r5.octah[1,3];
      s.lower[20] := r5.tetra[2,2];
      s.lower[21] := r5.octah[2,3];
      s.lower[22] := r5.tetra[3,2];              
      s.lower[23] := r5.octah[3,3];       
      s.lower[24] := r5.tetra[4,2];

      (* computing corner information *)

      c.right[0] := r1.tetra[0,0];
      c.right[1] := r2.octah[0,6];
      c.right[2] := r2.tetra[1,0];
      c.right[3] := r3.octah[1,6];
      c.right[4] := r3.tetra[2,0];
      c.right[5] := r4.octah[2,6];
      c.right[6] := r4.tetra[3,0];
      c.right[7] := r5.octah[3,6];
      c.right[8] := r5.tetra[4,0];

      c.left [0] := r1.tetra[0,1];
      c.left [1] := r2.octah[0,4];
      c.left [2] := r2.tetra[0,1];
      c.left [3] := r3.octah[0,4];
      c.left [4] := r3.tetra[0,1];
      c.left [5] := r4.octah[0,4];
      c.left [6] := r4.tetra[0,1];
      c.left [7] := r5.octah[0,4];
      c.left [8] := r5.tetra[0,1];


      c.front[0] := r5.tetra[0,3];
      c.front[1] := r5.octah[0,1];
      c.front[2] := r5.tetra[1,3];
      c.front[3] := r5.octah[1,1];
      c.front[4] := r5.tetra[2,3];
      c.front[5] := r5.octah[2,1];
      c.front[6] := r5.tetra[3,3];
      c.front[7] := r5.octah[3,1];
      c.front[8] := r5.tetra[4,3];


      FOR i := 0 TO 24 DO
        c.back [i] := s.lower[i];
      END;
 
      RETURN Pack{s,c};

     (* return an array of (sixteen) upper triangular faces of the level three
        that will be glue with the (sixteen) lower triangular faces of the
        level four.

			     /\                     /\     
			    /  \                   /  \  
			   / 0  \                 / 0  \
			  /------\               /------\
			 / \ 2  / \             / \ 2  / \
			/ 1 \  / 3 \           / 1 \  / 3 \  
		       /_____\/_____\         /_____\/_____\    
                      /\ 5  / \ 7  / \       /  5  / \  7 / \
                     /  \  /   \  /   \     /  \  /   \  /   \
                    / 4  \/  6  \/  8  \   / 4  \/  6  \/  8  \
                    --------------------\  ---------------------
	          / \ 10 /\ 12  /\ 14 /  \
	         /   \  /  \   /  \  /    \
	        /  9  \/ 11 \ / 13 \/  15  \
	        ----------------------------
	
                           s.upper               s.upper
    *)
    END
  END MakeLevTe5;


PROCEDURE MakeRowTe1() : Free =
  VAR f : Free;
  BEGIN
    f.tetra := NEW(REF ARRAY OF PAIR,1,4);
    WITH
      t = MakeTetraTopo(1,1)
    DO
      FOR i := 0 TO 3 DO
        f.tetra[0,i] := t[i];
      END;
      RETURN f; (* return one triangular *)
    END
  END MakeRowTe1;

PROCEDURE MakeRowTe2() : Free =
  VAR f : Free;
  BEGIN
    f.tetra := NEW(REF ARRAY OF PAIR,2,4);
    f.octah := NEW(REF ARRAY OF PAIR,1,8);
    WITH
      p = GlueTetraOctah(),
      t = MakeTetraTopo(1,1)
    DO
      EVAL Glue(Clock(p.octah[0,2]), t[1],  1);
      HideFace(p.octah[0,2]);
      FOR i := 0 TO 3 DO
        f.tetra[0,i] := p.tetra[0,i];
      END;

      FOR i := 0 TO 3 DO    
        f.tetra[1,i] := t[i];
      END;

      FOR i := 0 TO 7 DO
        f.octah[0,i] := p.octah[0,i];
      END;
      RETURN f; 
    END
  END MakeRowTe2;

PROCEDURE GlueTetraOctah() : Free =
  VAR f : Free ;
  BEGIN
    f.tetra := NEW(REF ARRAY OF PAIR,1,4);
    f.octah := NEW(REF ARRAY OF PAIR,1,8);
    WITH
      t = MakeTetraTopo(1,1),
      o = Squared.MakeOctahedronTriang(TRUE)
    DO
      EVAL Glue(Spin(o[0]), t[0], 1);
      HideFace(o[0]);
      FOR i := 0 TO 3 DO    
        f.tetra[0,i] := t[i];
      END;
      FOR j := 0 TO 7 DO
        f.octah[0,j]  := o[j];
      END;
      RETURN f;
    END;
  END GlueTetraOctah;

PROCEDURE MakeRowTe3() : Free =
  VAR f : Free;
  BEGIN
    f.tetra := NEW(REF ARRAY OF PAIR,4,4);
    f.octah := NEW(REF ARRAY OF PAIR,2,8);
    WITH
      r2 = MakeRowTe2(),
      r1 = GlueTetraOctah(),
      t  = MakeTetraTopo(1,1)
    DO
      (* free pairs:
         r1.octah [0,2] and t[0] 
         r2.tetra[0,1] and r2.octah[0,4]
      *)
      
      EVAL Glue(Spin(r2.octah[0,4]) , Clock(Spin(t[0])), 1);
      HideFace(r2.octah[0,4]);
      EVAL Glue(Spin(t[1])         ,  r1.octah[0,6], 1);
      HideFace(t[1]);
      EVAL Glue(Clock(r1.octah[0,2]), r2.tetra[0,1], 1);
      HideFace(r1.octah[0,2]);

      FOR i := 0 TO 3 DO
        f.tetra[0,i] := r1.tetra[0,i];
        f.tetra[1,i] := r2.tetra[0,i];
        f.tetra[2,i] := r2.tetra[1,i];
        f.tetra[3,i] := t[i];  
      END;
      FOR i := 0 TO 7 DO
        f.octah[0,i]  := r1.octah[0,i];
        f.octah[1,i]  := r2.octah[0,i];
      END;
      RETURN f;
    END
  END MakeRowTe3;

PROCEDURE MakeRowTe4() : Free =
  VAR f : Free;
  BEGIN
    f.tetra := NEW(REF ARRAY OF PAIR,6,4);
    f.octah := NEW(REF ARRAY OF PAIR,3,8);
    WITH
      r3 = MakeRowTe3(),
      r1 = GlueTetraOctah(),
      t  = MakeTetraTopo(1,1)
    DO
      (* free pairs:
         r1.octah[0,2] and t[0] 
         r3.tetra[0,1] and r3.octah[0,4]
      *)
      
      EVAL Glue(Spin(r3.octah[0,4]) , Spin(Clock(t[0])), 1); 
      HideFace      (r3.octah[0,4]);
      EVAL Glue(Spin(t[1])         ,  r1.octah[0,6], 1);
      HideFace      (t[1]);
      EVAL Glue(Clock(r1.octah[0,2]), r3.tetra[0,1], 1);
      HideFace       (r1.octah[0,2]);

      FOR i := 0 TO 3 DO
        f.tetra[0,i] := r1.tetra[0,i];
        f.tetra[1,i] := r3.tetra[0,i];
        f.tetra[2,i] := r3.tetra[1,i];
        f.tetra[3,i] := r3.tetra[2,i];
        f.tetra[4,i] := r3.tetra[3,i];
        f.tetra[5,i] := t[i];  
      END;

      FOR i := 0 TO 7 DO
        f.octah[0,i]  := r1.octah[0,i];
        f.octah[1,i]  := r3.octah[0,i];
        f.octah[2,i]  := r3.octah[1,i];
      END;
      RETURN f;
    END
  END MakeRowTe4;

PROCEDURE MakeRowTe5() : Free =
  VAR f : Free;
  BEGIN
    f.tetra := NEW(REF ARRAY OF PAIR,8,4);
    f.octah := NEW(REF ARRAY OF PAIR,5,8);
    WITH
      r3 = MakeRowTe4(),
      r1 = GlueTetraOctah(),
      t  = MakeTetraTopo(1,1)
    DO
      (* free pairs:
         r1.octah[0,2] and t[0] 
         r3.tetra[0,1] and r3.octah[0,4]
      *)
      
      EVAL Glue(Spin(r3.octah[0,4]) , Spin(Clock(t[0])),1);
      HideFace      (r3.octah[0,4]);
      EVAL Glue(Spin(t[1])         ,  r1.octah[0,6], 1);
      HideFace      (t[1]);
      EVAL Glue(Clock(r1.octah[0,2]), r3.tetra[0,1], 1);
      HideFace       (r1.octah[0,2]);

      FOR i := 0 TO 3 DO
        f.tetra[0,i] := r1.tetra[0,i];
        f.tetra[1,i] := r3.tetra[0,i];
        f.tetra[2,i] := r3.tetra[1,i];
        f.tetra[3,i] := r3.tetra[2,i];
        f.tetra[4,i] := r3.tetra[3,i];
        f.tetra[5,i] := r3.tetra[5,i];
        f.tetra[6,i] := r3.tetra[4,i];
        f.tetra[7,i] := t[i];  
      END;

      FOR i := 0 TO 7 DO
        f.octah[0,i]  := r1.octah[0,i];
        f.octah[1,i]  := r3.octah[0,i];
        f.octah[2,i]  := r3.octah[1,i];
        f.octah[3,i]  := r3.octah[2,i];
      END;
      RETURN f;
    END
  END MakeRowTe5;


PROCEDURE MakeRowTriang1() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 1);
  BEGIN
    WITH
      t = MakeTriangle()
    DO
      r[0] := t;
      RETURN r;
    END
  END MakeRowTriang1;

PROCEDURE MakeRowTriang2() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 3);
  BEGIN
    WITH
      p = GlueTwoTriang(),
      t = MakeRowTriang1()
    DO
      SetFnext  (p[1][2], Clock(t[0][2]));  
      SetEdgeAll(p[1][2], p[1][2].facetedge.edge);
            
      SetOrg(t[0][2],        OrgV(Clock(p[1][2])));
      SetOrg(Clock(t[0][2]), OrgV(p[1][2]));
      SetOrg(Clock(t[0][1]), OrgV(t[0][2]));
      SetOrg(      t[0][0] , OrgV(Clock(t[0][2])));

      FOR k := 0 TO 1 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k][i];
        END
      END;
      FOR j := 0 TO 2 DO
        r[2][j] := t[0][j];
      END
    END;
    RETURN r;
  END MakeRowTriang2;

PROCEDURE MakeRowTriang3() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 5);
  BEGIN
    WITH
      p = GlueTwoTriang(),
      t = MakeRowTriang2()
    DO
      SetFnext  (p[1][2], Clock(t[0][2]));
      SetEdgeAll(p[1][2], p[1][2].facetedge.edge);

      SetOrg(t[0][2],        OrgV(Clock(p[1][2])));
      SetOrg(Clock(t[0][2]), OrgV(p[1][2]));
      SetOrg(      t[0][0] , OrgV(Clock(t[0][2])));
      SetOrgCycle(Clock(t[0][1]), OrgV(t[0][2]));

      FOR k := 0 TO 1 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k][i];
        END
      END;
      FOR k := 2 TO 4 DO
        FOR j := 0 TO 2 DO
          r[k][j] := t[k-2][j];
        END
      END  
    END;
    RETURN r;
  END MakeRowTriang3;

PROCEDURE MakeRowTriang4() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 7);
  BEGIN
    WITH
      p = GlueTwoTriang(),
      t = MakeRowTriang3()
    DO
      SetFnext  (p[1][2], Clock(t[0][2]));
      SetEdgeAll(p[1][2], p[1][2].facetedge.edge);

      SetOrg(t[0][2],             OrgV(Clock(p[1][2])));
      SetOrg(Clock(t[0][2]),      OrgV(p[1][2]));
      SetOrg(      t[0][0] ,      OrgV(Clock(t[0][2])));
      SetOrgCycle(Clock(t[0][1]), OrgV(t[0][2]));
      
      FOR k := 0 TO 1 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k][i];
        END
      END;
      FOR k := 2 TO 6 DO
        FOR j := 0 TO 2 DO
          r[k][j] := t[k-2][j];
        END
      END
    END;
    RETURN r;
  END MakeRowTriang4;

PROCEDURE MakeRowTriang5() : REF ARRAY OF TRI =
  VAR r := NEW(REF ARRAY OF TRI, 9);
  BEGIN
    WITH
      p = GlueTwoTriang(),
      t = MakeRowTriang4()
    DO
      SetFnext  (p[1][2], Clock(t[0][2]));
      SetEdgeAll(p[1][2], p[1][2].facetedge.edge);

      SetOrg(t[0][2],             OrgV(Clock(p[1][2])));
      SetOrg(Clock(t[0][2]),      OrgV(p[1][2]));
      SetOrg(      t[0][0] ,      OrgV(Clock(t[0][2])));
      SetOrgCycle(Clock(t[0][1]), OrgV(t[0][2]));

      FOR k := 0 TO 1 DO
        FOR i := 0 TO 2 DO
          r[k][i] := p[k][i];
        END
      END;
      FOR k := 2 TO 8 DO
        FOR j := 0 TO 2 DO
          r[k][j] := t[k-2][j];
        END
      END
    END;
    RETURN r;
  END MakeRowTriang5;

PROCEDURE GlueTwoTriang() : ARRAY [0..1] OF TRI =
  VAR p : ARRAY [0..1] OF TRI;
  BEGIN
    WITH
      t1 = MakeTriangle(),
      t2 = MakeTriangle()
    DO
      SetFnext(t1[1], Clock(t2[1]));
      SetEdgeAll(t1[1], t1[1].facetedge.edge);
      
      SetOrg(t2[1],        OrgV(Clock(t1[1])));
      SetOrg(Clock(t2[1]), OrgV(t1[1]));
      SetOrg(Clock(t2[0]), OrgV(t2[1]));
      SetOrg(      t2[2],  OrgV(Clock(t2[1])));

      FOR i := 0 TO 2 DO
        p[0][i] := t1[i];
        p[1][i] := t2[i];
      END
    END;
    RETURN p;
  END GlueTwoTriang;

PROCEDURE GlueRefineTetra(
  fa, fb: CARDINAL;
  order : CARDINAL;
  ) : Pair =
  BEGIN
    IF order = 1 THEN
      WITH
        ca = MakeTetra1(),
        cb = MakeTetra1()
      DO
        IF    fa = 0  AND fb = 1  THEN
	  (* must be glue ca.right <--> cb.left  *)
	  EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);
          RETURN cb.left[0];
        ELSIF fa = 1  AND fb = 0  THEN
	  (* must be glue ca.left  <--> cb.right *)
	  EVAL Glue(Spin(ca.left[0]), cb.right[0], 1);
          RETURN ca.left[0];
        ELSIF fa = 3  AND fb = 2 THEN
	  (* must be glue ca.front <--> cb.back  *)
	  EVAL Glue(Spin(cb.back[0]), ca.front[0], 1);
          RETURN cb.back[0];
        ELSIF fa = 2  AND fb = 3  THEN
	  (* must be glue ca.back <--> cb.front  *)
	  EVAL Glue(Spin(cb.front[0]), ca.back[0], 1);
          RETURN cb.front[0];
        END
      END;
    ELSIF order = 2 THEN
      WITH
        ca = MakeTetra2(),
        cb = MakeTetra2()
      DO
        IF    fa = 0  AND fb = 1  THEN
	  (* must be glue ca.right <--> cb.left  *)
	  EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;
          RETURN cb.left[0];
        ELSIF fa = 1  AND fb = 0  THEN
          (* must be glue ca.left  <--> cb.right *)
          EVAL Glue(Spin(ca.left[0]), cb.right[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END;    
          RETURN ca.left[0];
        ELSIF fa = 3  AND fb = 2 THEN
	  (* must be glue ca.front <--> cb.back  *)
	  EVAL Glue(Spin(cb.back[0]), ca.front[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END;     
          RETURN cb.back[0];
        ELSIF fa = 2  AND fb = 3 THEN
	  (* must be glue ca.front <--> cb.back  *)
	  EVAL Glue(Spin(ca.back[0]), cb.front[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;    
          RETURN ca.back[0];
        END    
      END
    ELSIF order = 3 THEN
      WITH
        ca = MakeTetra3(),
        cb = MakeTetra3()
      DO
        IF    fa = 0  AND fb = 1  THEN
	  (* must be glue ca.right <--> cb.left  *)
	  EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;
          
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;    
          RETURN cb.left[0];
        ELSIF  fa = 1  AND fb = 0  THEN
	  (* must be glue ca.lef <--> cb.right   *)
	  EVAL Glue(Spin(ca.left[0]), cb.right[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END; 
          
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END; 
    
          RETURN ca.left[0];
        ELSIF fa = 3  AND fb = 2 THEN
	  (* must be glue ca.front <--> cb.back  *)
	  EVAL Glue(Spin (cb.back[0]), ca.front[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END; 
        
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END; 

          RETURN cb.back[0];
        ELSIF fa = 2  AND fb = 3 THEN
	  (* must be glue ca.back <--> cb.front  *)
	  EVAL Glue(Spin (ca.back[0]), cb.front[0], 1);
    
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;
        
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;     
          RETURN ca.back[0];
        END
      END  
    ELSIF order = 4 THEN
      WITH
        ca = MakeTetra4(),
        cb = MakeTetra4()
      DO
        IF    fa = 0  AND fb = 1  THEN
	  (* must be glue ca.right <--> cb.left  *)
	  EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);

          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;
    
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;
    
          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END; 
              
          RETURN cb.left[0];
        ELSIF fa = 1  AND fb = 0  THEN
	  (* must be glue cb.right <--> ca.left  *)
	  EVAL Glue(Spin(ca.left[0]), cb.right[0], 1);

          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END; 
    
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END;    
          
          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END; 
    
          RETURN ca.left[0];
        ELSIF fa = 3  AND fb = 2 THEN
	  (* must be glue ca.front <--> cb.back  *)
	  EVAL Glue(Spin (cb.back[0]), ca.front[0], 1);
    
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END; 
        
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END; 

          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END;      
    
          RETURN cb.back[0];
        ELSIF fa = 2  AND fb = 3 THEN
	  (* must be glue ca.back <--> cb.front  *)
	  EVAL Glue(Spin (ca.back[0]), cb.front[0], 1);

          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;
        
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;  

          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;   
    
          RETURN ca.back[0];
        END
      END
    ELSIF order = 5 THEN
      WITH
        ca = MakeTetra5(),
        cb = MakeTetra5()
      DO
        IF    fa = 0  AND fb = 1  THEN
	  (* must be glue ca.right <--> cb.left  *)
	  EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;
          
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;
          
          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END; 
          
          FOR i := 16 TO 24 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
            ELSE
              EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
            END
          END;     
          RETURN cb.left[0];
        ELSIF fa = 1  AND fb = 0  THEN
	  (* must be glue cb.right <--> ca.left  *)
	  EVAL Glue(Spin(ca.left[0]), cb.right[0], 1);
          
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END;    
          
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END;    
          
          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END; 
          
          FOR i := 16 TO 24 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.left[i]), cb.right[i], 1);
            ELSE
              EVAL Glue(Spin (ca.left[i]), Spin(Clock(cb.right[i])), 1);
            END
          END;     
          RETURN ca.left[0];
        ELSIF fa = 3  AND fb = 2 THEN
	  (* must be glue ca.front <--> cb.back  *)

	  EVAL Glue(Spin (cb.back[0]), ca.front[0], 1);

          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END;  

          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END;        
         
          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END;    
        
          FOR i := 16 TO 24 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (cb.back[i]), ca.front[i], 1);
            ELSE
              EVAL Glue(Clock(cb.back[i]), ca.front[i], 1);
            END
          END;
    
          RETURN cb.back[0];

        ELSIF fa = 2  AND fb = 3 THEN
          (* must be glue ca.back <--> cb.front  *)
	  EVAL Glue(Spin (ca.back[0]), cb.front[0], 1);
    
          FOR i := 1 TO 3 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;  
        
          FOR i := 4 TO 8 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;        
         
          FOR i := 9 TO 15 DO
            IF i MOD 2 # 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;    
    
          FOR i := 16 TO 24 DO
            IF i MOD 2 = 0 THEN
              EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
            ELSE
              EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
            END
          END;
    
          RETURN ca.back[0];
        END
      END
    END;
    RETURN Triangulation.MakeFacetEdge();
  END GlueRefineTetra;


PROCEDURE MakeMaximalGlue(order : CARDINAL) : Pair =
  BEGIN
    IF order = 1 THEN
      WITH
        ca = MakeTetra1(),
        cb = MakeTetra1()
      DO
	EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);  
	EVAL Glue(Spin(cb.front[0]), ca.back[0], 1);
        RETURN cb.front[0];
      END;
    ELSIF order = 2 THEN
      WITH
        ca = MakeTetra2(),
        cb = MakeTetra2()
      DO
	EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);  
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;    
          
	EVAL Glue(Spin(ca.back[0]), cb.front[0], 1);    
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END; 
        RETURN ca.back[0];    
      END
    ELSIF order = 3 THEN
      WITH
        ca = MakeTetra3(),
        cb = MakeTetra3()
      DO
	EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);  
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;  
          
        FOR i := 4 TO 8 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;

	EVAL Glue(Spin (ca.back[0]), cb.front[0], 1);
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;
        
        FOR i := 4 TO 8 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;     
        RETURN ca.back[0];
      END;
    ELSIF order = 4 THEN
      WITH
        ca = MakeTetra4(),
        cb = MakeTetra4()
      DO
	EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;
    
        FOR i := 4 TO 8 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;
    
        FOR i := 9 TO 15 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END; 
              
	EVAL Glue(Spin (ca.back[0]), cb.front[0], 1);
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;
        
        FOR i := 4 TO 8 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;  

        FOR i := 9 TO 15 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;   
        RETURN ca.back[0];
      END;
    ELSIF order = 5 THEN
      WITH
        ca = MakeTetra5(),
        cb = MakeTetra5()
      DO
	EVAL Glue(Spin(cb.left[0]), ca.right[0], 1);
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;
          
        FOR i := 4 TO 8 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;
          
        FOR i := 9 TO 15 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END; 
          
        FOR i := 16 TO 24 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (cb.left[i]), ca.right[i], 1);
          ELSE
            EVAL Glue(Spin (cb.left[i]), Spin(Clock(ca.right[i])), 1);
          END
        END;     

	EVAL Glue(Spin (ca.back[0]), cb.front[0], 1);
        FOR i := 1 TO 3 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;  
        
        FOR i := 4 TO 8 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;        
         
        FOR i := 9 TO 15 DO
          IF i MOD 2 # 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;    
    
        FOR i := 16 TO 24 DO
          IF i MOD 2 = 0 THEN
            EVAL Glue(Spin (ca.back[i]), cb.front[i], 1);
          ELSE
            EVAL Glue(Clock(ca.back[i]), cb.front[i], 1);
          END
        END;
        RETURN ca.back[0];
      END
    END;
    RETURN Triangulation.MakeFacetEdge();
  END MakeMaximalGlue;

PROCEDURE HideFace(a: Pair) =
  (* This procedure do the following sets:
     Faces :
       a.facetedge.face := FALSE
     Edges:
       a.facetedge.edge := FALSE
       Enext(a).facetedge.edge := FALSE
       Enext_1(a).facetedge.edge := FALSE
     Vertices:
       OrgV(a)          = FALSE
       OrgV(Enext(a))   = FALSE
       OrgV(Enext_1(a)) = FALSE
  *)
  BEGIN
    WITH
      b = Enext(a),
      c = Enext_1(a)
    DO
      (* setting face     *)
      a.facetedge.face.exists := FALSE;
      (* setting edges    *)
      a.facetedge.edge.exists := FALSE;
      b.facetedge.edge.exists := FALSE;
      c.facetedge.edge.exists := FALSE;
      (* setting vertices *)
      OrgV(a).exists := FALSE; OrgV(a).label := "VF";
      OrgV(b).exists := FALSE;
      OrgV(c).exists := FALSE;
    END
  END HideFace;

PROCEDURE SetLackVertices(ord: CARDINAL; co: Corner) =
  (* Set the lack vertices as existing on the boundary of a refined
     tetrahedron of order "ord".
  *)
  PROCEDURE SetVerticesOnEdge(a: Pair) =
    BEGIN
      WITH
        r = co.right[0].facetedge.edge.radius,
	v = OrgV(a)
      DO
        v.exists := TRUE;
	v.radius := r;
        v.label  := "VE";
      END
    END SetVerticesOnEdge;

  BEGIN
    IF ord = 2 THEN 
      SetVerticesOnEdge(co.right[0]);
      SetVerticesOnEdge(co.right[2]);
      SetVerticesOnEdge(co.right[3]);
      (* *)
      SetVerticesOnEdge(Clock(co.left[2]));
      (* *)
      SetVerticesOnEdge(co.left[3]);
      (* *)
      SetVerticesOnEdge(co.front[3]);
    ELSIF ord = 3 THEN
      SetVerticesOnEdge(co.right[0]);
      SetVerticesOnEdge(co.right[1]);
      SetVerticesOnEdge(co.right[2]);
      SetVerticesOnEdge(co.right[7]);
      SetVerticesOnEdge(co.right[8]);
      SetVerticesOnEdge(co.right[6]);
      (* *)
      SetVerticesOnEdge(Clock(co.left[2]));
      SetVerticesOnEdge(Clock(co.left[7]));
      (* *)
      SetVerticesOnEdge(co.left[5]);
      SetVerticesOnEdge(co.left[7]);
      (* *)
      SetVerticesOnEdge(co.front[6]);
      SetVerticesOnEdge(co.front[8]);
    ELSIF ord = 4 THEN
      SetVerticesOnEdge(co.right[0 ]);
      SetVerticesOnEdge(co.right[1 ]);
      SetVerticesOnEdge(co.right[4 ]);
      SetVerticesOnEdge(co.right[2 ]);
      SetVerticesOnEdge(co.right[7 ]);
      SetVerticesOnEdge(co.right[14]);
      SetVerticesOnEdge(co.right[15]);
      SetVerticesOnEdge(co.right[13]);
      SetVerticesOnEdge(co.right[11]);
      (* *)
      SetVerticesOnEdge(Clock(co.left[ 2]));
      SetVerticesOnEdge(Clock(co.left[ 7]));
      SetVerticesOnEdge(Clock(co.left[14]));
      (* *)
      SetVerticesOnEdge(co.left[10]);
      SetVerticesOnEdge(co.left[12]);
      SetVerticesOnEdge(co.left[14]);
      (* *)
      SetVerticesOnEdge(co.front[11]);
      SetVerticesOnEdge(co.front[13]);
      SetVerticesOnEdge(co.front[15]);

      (* setting vertex label on face *)
      
    ELSIF ord = 5 THEN      
      SetVerticesOnEdge(co.right[ 0]);
      SetVerticesOnEdge(co.right[ 1]);
      SetVerticesOnEdge(co.right[ 4]);
      SetVerticesOnEdge(co.right[ 9]);
      SetVerticesOnEdge(co.right[ 2]);
      SetVerticesOnEdge(co.right[ 7]);
      SetVerticesOnEdge(co.right[14]);
      SetVerticesOnEdge(co.right[23]);
      SetVerticesOnEdge(co.right[24]);
      SetVerticesOnEdge(co.right[22]);
      SetVerticesOnEdge(co.right[20]);
      SetVerticesOnEdge(co.right[18]);      
      (* *)
      SetVerticesOnEdge(Clock(co.left[ 2]));
      SetVerticesOnEdge(Clock(co.left[ 7]));
      SetVerticesOnEdge(Clock(co.left[14]));
      SetVerticesOnEdge(Clock(co.left[23]));
      (* *)
      SetVerticesOnEdge(co.left[17]);
      SetVerticesOnEdge(co.left[19]);
      SetVerticesOnEdge(co.left[21]);
      SetVerticesOnEdge(co.left[23]);
      (* *)
      SetVerticesOnEdge(co.front[18]);
      SetVerticesOnEdge(co.front[20]);
      SetVerticesOnEdge(co.front[22]);
      SetVerticesOnEdge(co.front[24]);
    END;
  END SetLackVertices;

PROCEDURE SetGrade(ord: CARDINAL; co: Corner) =
  (* Set edges and spheres underling on the boundary of a tetrahedron
     as thin cylinders and small spheres.
  *)
  PROCEDURE SetVertexOnNet(a: Pair) =
    BEGIN
      WITH
	vn = OrgV(a)
      DO
        vn.exists := TRUE;
	vn.radius := 0.025;
	vn.color  := R3.T{1.00,1.00,0.50};
      END
    END SetVertexOnNet;

  PROCEDURE SetEdgeOnNet(a: Pair) =
    BEGIN
      WITH
	en = a.facetedge.edge
      DO
        en.exists := TRUE;
	en.radius := 0.0025;
	en.color  := R3.T{1.00,1.00,0.5};
      END
    END SetEdgeOnNet;

  PROCEDURE SetGrade1() =
    BEGIN
      (* nothing *)
    END SetGrade1;

  PROCEDURE SetGrade2() =
    BEGIN
      (* 3 edges and 0 vertices for each face of the refined tetrahedron. *)
      (* On the right side. *)
      SetEdgeOnNet(Enext_1(co.right[0]));
      SetEdgeOnNet(        co.right[3] );
      SetEdgeOnNet(Enext  (co.right[2]));

      (* On the left side. *)
      SetEdgeOnNet(Enext_1(co.left[0]));
      SetEdgeOnNet(        co.left[2] );
      SetEdgeOnNet(Enext  (co.left[1]));

      (* On the front side. *)
      SetEdgeOnNet(        co.front[0] );
      SetEdgeOnNet(Enext  (co.front[1]));
      SetEdgeOnNet(Enext  (co.front[2]));

      (* On the back  side. *)
      SetEdgeOnNet(        co.back [0] );
      SetEdgeOnNet(Enext  (co.back [1]));
      SetEdgeOnNet(Enext_1(co.back [2]));	    
    END SetGrade2;

  PROCEDURE SetGrade3() =
    BEGIN
      (* 9 edges and 1 vertices for each face of the refined tetrahedron. *)
      SetGrade2();
      (* On the right side. *)
      SetEdgeOnNet(Enext_1(co.right[3]));
      SetEdgeOnNet(Enext_1(co.right[1]));

      SetEdgeOnNet(        co.right[8] );
      SetEdgeOnNet(Enext  (co.right[7]));
      SetEdgeOnNet(        co.right[6] );
      SetEdgeOnNet(Enext  (co.right[5]));

      SetVertexOnNet(co.right[3]);
      (* On the left side. *)
      SetEdgeOnNet(Enext_1(co.left[1]));
      SetEdgeOnNet(Enext_1(co.left[3]));

      SetEdgeOnNet(Enext  (co.left[4]));
      SetEdgeOnNet(        co.left[5] );
      SetEdgeOnNet(Enext  (co.left[6]));
      SetEdgeOnNet(        co.left[7] );

      SetVertexOnNet(co.left[3]);      
      (* On the front side. *)
      SetEdgeOnNet(        co.front[1] );
      SetEdgeOnNet(        co.front[3] );

      SetEdgeOnNet(Enext  (co.front[4]));
      SetEdgeOnNet(Enext  (co.front[5]));
      SetEdgeOnNet(Enext  (co.front[6]));
      SetEdgeOnNet(Enext  (co.front[7]));

      SetVertexOnNet(co.front[3]); 
      (* On the back  side. *)
      SetEdgeOnNet(        co.back [1] );
      SetEdgeOnNet(        co.back [3] );

      SetEdgeOnNet(Enext  (co.back [4]));
      SetEdgeOnNet(Enext_1(co.back [5]));
      SetEdgeOnNet(Enext  (co.back [6]));
      SetEdgeOnNet(Enext_1(co.back [7]));

      SetVertexOnNet(co.back[3]);     
    END SetGrade3;

  PROCEDURE SetGrade4() =
    BEGIN
      (* 18 edges and 3 vertices for each face of the refined tetrahedron. *)
      SetGrade3();
      (* On the right side. *)
      SetEdgeOnNet(Enext_1(co.right[8]));
      SetEdgeOnNet(Enext_1(co.right[6]));
      SetEdgeOnNet(Enext_1(co.right[4]));

      SetEdgeOnNet(        co.right[15] );
      SetEdgeOnNet(Enext  (co.right[14]));
      SetEdgeOnNet(        co.right[13] );
      SetEdgeOnNet(Enext  (co.right[12]));
      SetEdgeOnNet(        co.right[11] );
      SetEdgeOnNet(Enext  (co.right[10]));

      SetVertexOnNet(co.right[8]);
      SetVertexOnNet(co.right[6]);
      (* On the left side. *)
      SetEdgeOnNet(Enext_1(co.left[4]));
      SetEdgeOnNet(Enext_1(co.left[6]));
      SetEdgeOnNet(Enext_1(co.left[8]));

      SetEdgeOnNet(Enext  (co.left[9 ]));
      SetEdgeOnNet(        co.left[10] );
      SetEdgeOnNet(Enext  (co.left[11]));
      SetEdgeOnNet(        co.left[12] );
      SetEdgeOnNet(Enext  (co.left[13]));
      SetEdgeOnNet(        co.left[14] );

      SetVertexOnNet(co.left[8]);
      SetVertexOnNet(co.left[6]);
      (* On the front side. *)
      SetEdgeOnNet(        co.front[4] );
      SetEdgeOnNet(        co.front[6] );
      SetEdgeOnNet(        co.front[8] );

      SetEdgeOnNet(Enext  (co.front[ 9]));
      SetEdgeOnNet(Enext  (co.front[10]));
      SetEdgeOnNet(Enext  (co.front[11]));
      SetEdgeOnNet(Enext  (co.front[12]));
      SetEdgeOnNet(Enext  (co.front[13]));
      SetEdgeOnNet(Enext  (co.front[14]));

      SetVertexOnNet(co.front[8]);
      SetVertexOnNet(co.front[6]);
            
      (* On the back  side. *)
      SetEdgeOnNet(        co.back [4] );
      SetEdgeOnNet(        co.back [6] );
      SetEdgeOnNet(        co.back [8] );

      SetEdgeOnNet(Enext  (co.back [ 9]));
      SetEdgeOnNet(Enext_1(co.back [10]));
      SetEdgeOnNet(Enext  (co.back [11]));
      SetEdgeOnNet(Enext_1(co.back [12]));
      SetEdgeOnNet(Enext  (co.back [13]));
      SetEdgeOnNet(Enext_1(co.back [14]));

      SetVertexOnNet(co.back[8]);
      SetVertexOnNet(co.back[6]);
    END SetGrade4;

  PROCEDURE SetGrade5() =
    BEGIN
      (* 10 edges and 6 vertices for each face of the refined tetrahedron. *)
      SetGrade4();
      (* On the right side. *)
      SetEdgeOnNet(Enext_1(co.right[15]));
      SetEdgeOnNet(Enext_1(co.right[13]));
      SetEdgeOnNet(Enext_1(co.right[11]));

      SetEdgeOnNet(Enext_1(co.right[ 9]));
      
      SetEdgeOnNet(        co.right[24] );
      SetEdgeOnNet(Enext  (co.right[23]));
      SetEdgeOnNet(        co.right[22] );
      SetEdgeOnNet(Enext  (co.right[21]));
      SetEdgeOnNet(        co.right[20] );
      SetEdgeOnNet(Enext  (co.right[19]));
      SetEdgeOnNet(        co.right[18] );
      SetEdgeOnNet(Enext  (co.right[17]));
      
      SetVertexOnNet(co.right[15]);
      SetVertexOnNet(co.right[13]);
      SetVertexOnNet(co.right[11]);
      
      (* On the left side. *)
      SetEdgeOnNet(Enext_1(co.left[ 9]));
      SetEdgeOnNet(Enext_1(co.left[11]));
      SetEdgeOnNet(Enext_1(co.left[13]));
      SetEdgeOnNet(Enext_1(co.left[15]));
      
      SetEdgeOnNet(Enext  (co.left[16]));
      SetEdgeOnNet(        co.left[17] );
      SetEdgeOnNet(Enext  (co.left[18]));
      SetEdgeOnNet(        co.left[19] );
      SetEdgeOnNet(Enext  (co.left[20]));
      SetEdgeOnNet(        co.left[21] );
      SetEdgeOnNet(Enext  (co.left[22]));
      SetEdgeOnNet(        co.left[23] );
      
      SetVertexOnNet(co.left[15]);
      SetVertexOnNet(co.left[13]);
      SetVertexOnNet(co.left[11]);
      (* On the front side. *)
      SetEdgeOnNet(        co.front[ 9] );
      SetEdgeOnNet(        co.front[11] );
      SetEdgeOnNet(        co.front[13] );
      SetEdgeOnNet(        co.front[15] );
      
      SetEdgeOnNet(Enext  (co.front[16]));
      SetEdgeOnNet(Enext  (co.front[17]));
      SetEdgeOnNet(Enext  (co.front[18]));
      SetEdgeOnNet(Enext  (co.front[19]));
      SetEdgeOnNet(Enext  (co.front[20]));
      SetEdgeOnNet(Enext  (co.front[21]));
      SetEdgeOnNet(Enext  (co.front[22]));
      SetEdgeOnNet(Enext  (co.front[23]));
      
      SetVertexOnNet(co.front[15]);
      SetVertexOnNet(co.front[13]);
      SetVertexOnNet(co.front[11]);     
      (* On the back  side. *)
      SetEdgeOnNet(        co.back [ 9] );
      SetEdgeOnNet(        co.back [11] );
      SetEdgeOnNet(        co.back [13] );
      SetEdgeOnNet(        co.back [15] );

      SetEdgeOnNet(Enext  (co.back [16]));
      SetEdgeOnNet(Enext_1(co.back [17]));
      SetEdgeOnNet(Enext  (co.back [18]));
      SetEdgeOnNet(Enext_1(co.back [19]));
      SetEdgeOnNet(Enext  (co.back [20]));
      SetEdgeOnNet(Enext_1(co.back [21]));
      SetEdgeOnNet(Enext  (co.back [22]));
      SetEdgeOnNet(Enext_1(co.back [23]));

      SetVertexOnNet(co.back[15]);
      SetVertexOnNet(co.back[13]);
      SetVertexOnNet(co.back[11]);
    END SetGrade5;

    <* FATAL Thread.Alerted, Wr.Failure *>
  BEGIN
    IF    ord = 1 THEN SetGrade1();
    ELSIF ord = 2 THEN SetGrade2();
    ELSIF ord = 3 THEN SetGrade3();
    ELSIF ord = 4 THEN SetGrade4();
    ELSIF ord = 5 THEN SetGrade5();
    ELSE
      Wr.PutText(stderr,"Order must be less equal to 5\n");
      <* ASSERT ord <= 5 *>
    END;
  END SetGrade;

PROCEDURE MakeTriangle() : ARRAY [0..2] OF Pair =
  (* Builds a triangular face and set the three pairs facetedges with the
     same face component.
  *)
  VAR t : ARRAY [0..2] OF Pair;
  BEGIN
    WITH
      a = MakeFacetEdge(),
      b = MakeFacetEdge(),
      c = MakeFacetEdge(),
      f = a.facetedge.face,
      u = MakeVertex(),
      v = MakeVertex(),
      w = MakeVertex()
    DO               
      SetOrg(a, u); SetOrg(Clock(a),v);
      SetEnext(a,b); SetFace(b,f);
      SetOrg(b,v); SetOrg(Clock(b),w);
      SetEnext(b,c); SetFace(c,f);
      SetOrg(c, w);  SetOrg(Clock(c), OrgV(a));
      <* ASSERT Enext(c) = a *>

      t[0] := a;
      t[1] := b;
      t[2] := c;

      RETURN t;
    END
  END MakeTriangle;

PROCEDURE SetOrgCycle(a: Pair; n: Vertex) =
  (* Set all pairs adjacent to "a" and underling on the 2D star of the
     vertex "n" with this vertex.
  *)

  PROCEDURE SetOrgFace(b: Pair) =
    (* Set all pairs adjacent to "a" on the Fnext's ring with the vertex "n".*)
    VAR bn: Pair := b;
    BEGIN
      REPEAT
        SetOrg(bn,n);
        bn := Fnext(bn);
      UNTIL bn = b;
    END SetOrgFace;

  VAR an: Pair := a;
  BEGIN
    REPEAT
      SetOrgFace(an);
      an := Onext(an);
    UNTIL an = a;
  END SetOrgCycle;

PROCEDURE Enext0(a: Pair) : Pair =
  BEGIN
    RETURN a
  END Enext0;

PROCEDURE Enext1(a: Pair) : Pair =
  BEGIN
    RETURN Enext(a);
  END Enext1;

PROCEDURE Enext2(a: Pair) : Pair =
  BEGIN
    RETURN Enext(Enext(a));
  END Enext2;

PROCEDURE ClockSpinEnext0(a: Pair) : Pair =
  BEGIN
    RETURN Clock(Spin(Enext0(a)))
  END ClockSpinEnext0;

PROCEDURE ClockSpinEnext1(a: Pair) : Pair =
  BEGIN
    RETURN Clock(Spin(Enext1(a)))
  END ClockSpinEnext1;

PROCEDURE ClockSpinEnext2(a: Pair) : Pair =
  BEGIN
    RETURN Clock(Spin(Enext2(a)))
  END ClockSpinEnext2;

PROCEDURE FnextEnext(a: Pair) : Pair =
  BEGIN
    RETURN Fnext(Enext(a))
  END FnextEnext;
    
PROCEDURE PairsOnFrontier(
  READONLY co: Corner;
  cnum, order  : CARDINAL;
  ) : REF PAIR =
  VAR nc : REF PAIR;   
  BEGIN
    nc := NEW(REF PAIR, order*order); 
    IF cnum = 0 THEN
      IF order = 1 THEN
	nc[ 0] := Enext0(co.right[ 0]);
      ELSIF order = 2 THEN
	nc[ 0] := Enext0(co.right[ 1]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext0(co.right[ 0]);
	(* *)
	nc[ 3] := Enext0(co.right[ 3]);
      ELSIF order = 3 THEN
	nc[ 0] := Enext0(co.right[ 4]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext0(co.right[ 1]);
	nc[ 3] := FnextEnext(nc[2]);
	nc[ 4] := Enext0(co.right[ 0]);
	(* *)
	nc[ 5] := Enext0(co.right[ 6]);
	nc[ 6] := FnextEnext(nc[5]);
	nc[ 7] := Enext0(co.right[ 3]);
	(* *)
	nc[ 8] := Enext0(co.right[ 8]);
      ELSIF order = 4 THEN
	nc[ 0] := Enext0(co.right[ 9]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext0(co.right[ 4]);
	nc[ 3] := FnextEnext(nc[ 2]);
	nc[ 4] := Enext0(co.right[ 1]);
	nc[ 5] := FnextEnext(nc[ 4]);
	nc[ 6] := Enext0(co.right[ 0]);  
	(* *)
	nc[ 7] := Enext0(co.right[11]);
	nc[ 8] := FnextEnext(nc[ 7]);
	nc[ 9] := Enext0(co.right[ 6]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := Enext0(co.right[ 3]);
	(* *)
	nc[12] := Enext0(co.right[13]);
	nc[13] := FnextEnext(nc[12]);
	nc[14] := Enext0(co.right[ 8]);
	(* *)
	nc[15] := Enext0(co.right[15]);
      ELSIF order = 5 THEN
	nc[ 0] := Enext0(co.right[16]);
	nc[ 1] := FnextEnext(nc[ 0]);
	nc[ 2] := Enext0(co.right[ 9]);
	nc[ 3] := FnextEnext(nc[ 2]);
	nc[ 4] := Enext0(co.right[ 4]);
	nc[ 5] := FnextEnext(nc[ 4]);
	nc[ 6] := Enext0(co.right[ 1]);  
	nc[ 7] := FnextEnext(nc[ 6]);
	nc[ 8] := Enext0(co.right[ 0]);
	(* *)
	nc[ 9] := Enext0(co.right[18]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := Enext0(co.right[11]);
	nc[12] := FnextEnext(nc[11]);
	nc[13] := Enext0(co.right[ 6]);
	nc[14] := FnextEnext(nc[13]);
	nc[15] := Enext0(co.right[ 3]);
	(* *)
	nc[16] := Enext0(co.right[20]);
	nc[17] := FnextEnext(nc[16]);
	nc[18] := Enext0(co.right[13]);
	nc[19] := FnextEnext(nc[18]);
	nc[20] := Enext0(co.right[ 8]);
	(* *)
	nc[21] := Enext0(co.right[22]);
	nc[22] := FnextEnext(nc[21]);
	nc[23] := Enext0(co.right[15]);
	(* *)
	nc[24] := Enext0(co.right[24]);
      END
    END;
    IF cnum = 1 THEN
      IF order = 1 THEN
	nc[ 0] := Enext1(co.right[ 0]);
      ELSIF order = 2 THEN
	nc[ 0] := Enext1(co.right[ 0]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext1(co.right[ 3]);
	(* *)
	nc[ 3] := Enext1(co.right[ 1]);
      ELSIF order = 3 THEN
	nc[ 0] := Enext1(co.right[ 0]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext1(co.right[ 3]);
	nc[ 3] := FnextEnext(nc[2]);
	nc[ 4] := Enext1(co.right[ 8]);
	(* *)
	nc[ 5] := Enext1(co.right[ 1]);
	nc[ 6] := FnextEnext(nc[5]);
	nc[ 7] := Enext1(co.right[ 6]);
	(* *)
	nc[ 8] := Enext1(co.right[ 4]);
      ELSIF order = 4 THEN
	nc[ 0] := Enext1(co.right[ 0]);
	nc[ 1] := FnextEnext(nc[ 0]);
	nc[ 2] := Enext1(co.right[ 3]);
	nc[ 3] := FnextEnext(nc[ 2]);
	nc[ 4] := Enext1(co.right[ 8]);
	nc[ 5] := FnextEnext(nc[ 4]);
	nc[ 6] := Enext1(co.right[15]);  
	(* *)
	nc[ 7] := Enext1(co.right[ 1]);
	nc[ 8] := FnextEnext(nc[ 7]);
	nc[ 9] := Enext1(co.right[ 6]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := Enext1(co.right[13]);
	(* *)
	nc[12] := Enext1(co.right[ 4]);
	nc[13] := FnextEnext(nc[12]);
	nc[14] := Enext1(co.right[11]);
	(* *)
	nc[15] := Enext1(co.right[ 9]);
      ELSIF order = 5 THEN
	nc[ 0] := Enext1(co.right[ 0]);
	nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext1(co.right[ 3]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext1(co.right[ 8]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext1(co.right[15]);  
        nc[ 7] := FnextEnext(nc[ 6]);
        nc[ 8] := Enext1(co.right[24]);
        (* *)
	nc[ 9] := Enext1(co.right[ 1]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := Enext1(co.right[ 6]);
	nc[12] := FnextEnext(nc[11]);
	nc[13] := Enext1(co.right[13]);
	nc[14] := FnextEnext(nc[13]);
	nc[15] := Enext1(co.right[22]);
	(* *)
	nc[16] := Enext1(co.right[ 4]);
	nc[17] := FnextEnext(nc[16]);
	nc[18] := Enext1(co.right[11]);
	nc[19] := FnextEnext(nc[18]);
	nc[20] := Enext1(co.right[20]);
	(* *)
	nc[21] := Enext1(co.right[ 9]);
	nc[22] := FnextEnext(nc[21]);
	nc[23] := Enext1(co.right[18]);
	(* *)
	nc[24] := Enext1(co.right[16]);
      END
    END;
    IF cnum = 2 THEN
      IF order = 1 THEN
        nc[ 0] := Enext2(co.right[ 0]);
      ELSIF order = 2 THEN
        nc[ 0] := Enext2(co.right[ 3]);
        nc[ 1] := FnextEnext(nc[0]);
        nc[ 2] := Enext2(co.right[ 1]);
        (* *)
        nc[ 3] := Enext2(co.right[ 0]);
      ELSIF order = 3 THEN
        nc[ 0] := Enext2(co.right[ 8]);
        nc[ 1] := FnextEnext(nc[0]);
        nc[ 2] := Enext2(co.right[ 6]);
        nc[ 3] := FnextEnext(nc[2]);
        nc[ 4] := Enext2(co.right[ 4]);
        (* *)
        nc[ 5] := Enext2(co.right[ 3]);
        nc[ 6] := FnextEnext(nc[5]);
        nc[ 7] := Enext2(co.right[ 1]);
        (* *)
        nc[ 8] := Enext2(co.right[ 0]);
      ELSIF order = 4 THEN
        nc[ 0] := Enext2(co.right[15]);
        nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext2(co.right[13]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext2(co.right[11]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext2(co.right[ 9]);  
        (* *)
        nc[ 7] := Enext2(co.right[ 8]);
        nc[ 8] := FnextEnext(nc[ 7]);
        nc[ 9] := Enext2(co.right[ 6]);
        nc[10] := FnextEnext(nc[ 9]);
        nc[11] := Enext2(co.right[ 4]);
        (* *)
        nc[12] := Enext2(co.right[ 3]);
        nc[13] := FnextEnext(nc[12]);
        nc[14] := Enext2(co.right[ 1]);
        (* *)
        nc[15] := Enext2(co.right[ 0]);
      ELSIF order = 5 THEN
        nc[ 0] := Enext2(co.right[24]);
        nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext2(co.right[22]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext2(co.right[20]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext2(co.right[18]);  
        nc[ 7] := FnextEnext(nc[ 6]);
        nc[ 8] := Enext2(co.right[16]);
        (* *)
        nc[ 9] := Enext2(co.right[15]);
        nc[10] := FnextEnext(nc[ 9]);
        nc[11] := Enext2(co.right[13]);
        nc[12] := FnextEnext(nc[11]);
        nc[13] := Enext2(co.right[11]);
        nc[14] := FnextEnext(nc[13]);
        nc[15] := Enext2(co.right[ 9]);
        (* *)
        nc[16] := Enext2(co.right[ 8]);
        nc[17] := FnextEnext(nc[16]);
        nc[18] := Enext2(co.right[ 6]);
        nc[19] := FnextEnext(nc[18]);
        nc[20] := Enext2(co.right[ 4]);
        (* *)
        nc[21] := Enext2(co.right[ 3]);
        nc[22] := FnextEnext(nc[21]);
        nc[23] := Enext2(co.right[ 1]);
        (* *)
        nc[24] := Enext2(co.right[ 0]);
      END
    END;
    IF cnum = 3 THEN
      IF order = 1 THEN
        nc[ 0] := Enext0(co.left[ 0]);
      ELSIF order = 2 THEN
        nc[ 0] := Enext0(co.left[ 1]);
        nc[ 1] := FnextEnext(nc[0]);
        nc[ 2] := Enext0(co.left[ 0]);
        (* *)
        nc[ 3] := Enext0(co.left[ 3]);
      ELSIF order = 3 THEN
        nc[ 0] := Enext0(co.left[ 4]);
        nc[ 1] := FnextEnext(nc[0]);
        nc[ 2] := Enext0(co.left[ 1]);
        nc[ 3] := FnextEnext(nc[2]);
        nc[ 4] := Enext0(co.left[ 0]);
        (* *)
        nc[ 5] := Enext0(co.left[ 6]);
        nc[ 6] := FnextEnext(nc[5]);
        nc[ 7] := Enext0(co.left[ 3]);
        (* *)
        nc[ 8] := Enext0(co.left[ 8]);
      ELSIF order = 4 THEN
        nc[ 0] := Enext0(co.left[ 9]);
        nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext0(co.left[ 4]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext0(co.left[ 1]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext0(co.left[ 0]);  
        (* *)
        nc[ 7] := Enext0(co.left[11]);
        nc[ 8] := FnextEnext(nc[ 7]);
        nc[ 9] := Enext0(co.left[ 6]);
        nc[10] := FnextEnext(nc[ 9]);
        nc[11] := Enext0(co.left[ 3]);
        (* *)
        nc[12] := Enext0(co.left[13]);
        nc[13] := FnextEnext(nc[12]);
        nc[14] := Enext0(co.left[ 8]);
        (* *)
        nc[15] := Enext0(co.left[15]);
      ELSIF order = 5 THEN
        nc[ 0] := Enext0(co.left[16]);
        nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext0(co.left[ 9]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext0(co.left[ 4]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext0(co.left[ 1]);  
        nc[ 7] := FnextEnext(nc[ 6]);
        nc[ 8] := Enext0(co.left[ 0]);
        (* *)
        nc[ 9] := Enext0(co.left[18]);
        nc[10] := FnextEnext(nc[ 9]);
        nc[11] := Enext0(co.left[11]);
        nc[12] := FnextEnext(nc[11]);
        nc[13] := Enext0(co.left[ 6]);
        nc[14] := FnextEnext(nc[13]);
        nc[15] := Enext0(co.left[ 3]);
        (* *)
        nc[16] := Enext0(co.left[20]);
        nc[17] := FnextEnext(nc[16]);
        nc[18] := Enext0(co.left[13]);
        nc[19] := FnextEnext(nc[18]);
        nc[20] := Enext0(co.left[ 8]);
        (* *)
        nc[21] := Enext0(co.left[22]);
        nc[22] := FnextEnext(nc[21]);  
        nc[23] := Enext0(co.left[15]);
        (* *)
        nc[24] := Enext0(co.left[24]);
      END
    END;    
    IF cnum = 4 THEN
      IF order = 1 THEN
        nc[ 0] := Enext1(co.left[ 0]);
      ELSIF order = 2 THEN
        nc[ 0] := Enext1(co.left[ 0]);
        nc[ 1] := FnextEnext(nc[0]);
        nc[ 2] := Enext1(co.left[ 3]);
        (* *)
        nc[ 3] := Enext1(co.left[ 1]);
      ELSIF order = 3 THEN
        nc[ 0] := Enext1(co.left[ 0]);
        nc[ 1] := FnextEnext(nc[0]);
        nc[ 2] := Enext1(co.left[ 3]);
        nc[ 3] := FnextEnext(nc[2]);
        nc[ 4] := Enext1(co.left[ 8]);
        (* *)
        nc[ 5] := Enext1(co.left[ 1]);
        nc[ 6] := FnextEnext(nc[5]);
        nc[ 7] := Enext1(co.left[ 6]);
        (* *)
        nc[ 8] := Enext1(co.left[ 4]);
      ELSIF order = 4 THEN
        nc[ 0] := Enext1(co.left[ 0]);
        nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext1(co.left[ 3]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext1(co.left[ 8]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext1(co.left[15]);  
        (* *)
        nc[ 7] := Enext1(co.left[ 1]);
        nc[ 8] := FnextEnext(nc[ 7]);
        nc[ 9] := Enext1(co.left[ 6]);
        nc[10] := FnextEnext(nc[ 9]);
        nc[11] := Enext1(co.left[13]);
        (* *)
        nc[12] := Enext1(co.left[ 4]);
        nc[13] := FnextEnext(nc[12]);
        nc[14] := Enext1(co.left[11]);
        (* *)
        nc[15] := Enext1(co.left[ 9]);
      ELSIF order = 5 THEN
        nc[ 0] := Enext1(co.left[ 0]);
        nc[ 1] := FnextEnext(nc[ 0]);
        nc[ 2] := Enext1(co.left[ 3]);
        nc[ 3] := FnextEnext(nc[ 2]);
        nc[ 4] := Enext1(co.left[ 8]);
        nc[ 5] := FnextEnext(nc[ 4]);
        nc[ 6] := Enext1(co.left[15]);  
        nc[ 7] := FnextEnext(nc[ 6]);
        nc[ 8] := Enext1(co.left[24]);
        (* *)
        nc[ 9] := Enext1(co.left[ 1]);
        nc[10] := FnextEnext(nc[ 9]);
        nc[11] := Enext1(co.left[ 6]);
        nc[12] := FnextEnext(nc[11]);
        nc[13] := Enext1(co.left[13]);
        nc[14] := FnextEnext(nc[13]);
        nc[15] := Enext1(co.left[22]);
        (* *)
        nc[16] := Enext1(co.left[ 4]);
        nc[17] := FnextEnext(nc[16]);
        nc[18] := Enext1(co.left[11]);
        nc[19] := FnextEnext(nc[18]);
        nc[20] := Enext1(co.left[20]);
        (* *)
        nc[21] := Enext1(co.left[ 9]);
        nc[22] := FnextEnext(nc[21]);
        nc[23] := Enext1(co.left[18]);
        (* *)
        nc[24] := Enext1(co.left[16]);
      END
    END;
    IF cnum = 5 THEN
      IF order = 1 THEN
	nc[ 0] := Enext2(co.left[ 0]);
      ELSIF order = 2 THEN
	nc[ 0] := Enext2(co.left[ 3]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext2(co.left[ 1]);
	(* *)
        nc[ 3] := Enext2(co.left[ 0]);
      ELSIF order = 3 THEN
	nc[ 0] := Enext2(co.left[ 8]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := Enext2(co.left[ 6]);
	nc[ 3] := FnextEnext(nc[2]);
	nc[ 4] := Enext2(co.left[ 4]);
	(* *)
	nc[ 5] := Enext2(co.left[ 3]);
	nc[ 6] := FnextEnext(nc[5]);
	nc[ 7] := Enext2(co.left[ 1]);
	(* *)
	nc[ 8] := Enext2(co.left[ 0]);
      ELSIF order = 4 THEN
	nc[ 0] := Enext2(co.left[15]);
	nc[ 1] := FnextEnext(nc[ 0]);
	nc[ 2] := Enext2(co.left[13]);
	nc[ 3] := FnextEnext(nc[ 2]);
	nc[ 4] := Enext2(co.left[11]);
	nc[ 5] := FnextEnext(nc[ 4]);
	nc[ 6] := Enext2(co.left[ 9]);  
	(* *)
	nc[ 7] := Enext2(co.left[ 8]);
	nc[ 8] := FnextEnext(nc[ 7]);
	nc[ 9] := Enext2(co.left[ 6]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := Enext2(co.left[ 4]);
	(* *)
	nc[12] := Enext2(co.left[ 3]);
	nc[13] := FnextEnext(nc[12]);  
	nc[14] := Enext2(co.left[ 1]);
	(* *)
	nc[15] := Enext2(co.left[ 0]);
      ELSIF order = 5 THEN
	nc[ 0] := Enext2(co.left[24]);
	nc[ 1] := FnextEnext(nc[ 0]); 
	nc[ 2] := Enext2(co.left[22]);
	nc[ 3] := FnextEnext(nc[ 2]); 
	nc[ 4] := Enext2(co.left[20]);
	nc[ 5] := FnextEnext(nc[ 4]); 
	nc[ 6] := Enext2(co.left[18]);  
	nc[ 7] := FnextEnext(nc[ 6]);  
	nc[ 8] := Enext2(co.left[16]);
	(* *)
	nc[ 9] := Enext2(co.left[15]);
	nc[10] := FnextEnext(nc[ 9]);  
	nc[11] := Enext2(co.left[13]);
	nc[12] := FnextEnext(nc[11]);  
	nc[13] := Enext2(co.left[11]);
	nc[14] := FnextEnext(nc[13]); 
	nc[15] := Enext2(co.left[ 9]);
	(* *)
	nc[16] := Enext2(co.left[ 8]);
	nc[17] := FnextEnext(nc[16]);  
	nc[18] := Enext2(co.left[ 6]);
	nc[19] := FnextEnext(nc[18]);  
        nc[20] := Enext2(co.left[ 4]);
	(* *)
	nc[21] := Enext2(co.left[ 3]);
	nc[22] := FnextEnext(nc[21]);  
	nc[23] := Enext2(co.left[ 1]);
	(* *)
	nc[24] := Enext2(co.left[ 0]);
      END
    END;
    IF cnum = 6 THEN
      IF order = 1 THEN
	nc[ 0] := ClockSpinEnext1(co.front[ 0]);
      ELSIF order = 2 THEN
	nc[ 0] := ClockSpinEnext1(co.front[ 0]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := ClockSpinEnext1(co.front[ 3]);
	(* *)
	nc[ 3] := ClockSpinEnext1(co.front[ 1]);
      ELSIF order = 3 THEN
	nc[ 0] := ClockSpinEnext1(co.front[ 0]);
	nc[ 1] := FnextEnext(nc[0]);
	nc[ 2] := ClockSpinEnext1(co.front[ 3]);
	nc[ 3] := FnextEnext(nc[2]);
	nc[ 4] := ClockSpinEnext1(co.front[ 8]);
	(* *)
	nc[ 5] := ClockSpinEnext1(co.front[ 1]);
	nc[ 6] := FnextEnext(nc[5]);
	nc[ 7] := ClockSpinEnext1(co.front[ 6]);
	(* *)
	nc[ 8] := ClockSpinEnext1(co.front[ 4]);
      ELSIF order = 4 THEN
	nc[ 0] := ClockSpinEnext1(co.front[ 0]);
	nc[ 1] := FnextEnext(nc[ 0]);
	nc[ 2] := ClockSpinEnext1(co.front[ 3]);
	nc[ 3] := FnextEnext(nc[ 2]);
	nc[ 4] := ClockSpinEnext1(co.front[ 8]);
	nc[ 5] := FnextEnext(nc[ 4]);
	nc[ 6] := ClockSpinEnext1(co.front[15]);  
	(* *)
	nc[ 7] := ClockSpinEnext1(co.front[ 1]);
	nc[ 8] := FnextEnext(nc[ 7]);
	nc[ 9] := ClockSpinEnext1(co.front[ 6]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := ClockSpinEnext1(co.front[13]);
	(* *)
	nc[12] := ClockSpinEnext1(co.front[ 4]);
	nc[13] := FnextEnext(nc[12]);
	nc[14] := ClockSpinEnext1(co.front[11]);
	(* *)
	nc[15] := ClockSpinEnext1(co.front[ 9]);
      ELSIF order = 5 THEN
	nc[ 0] := ClockSpinEnext1(co.front[ 0]);
	nc[ 1] := FnextEnext(nc[ 0]); 
	nc[ 2] := ClockSpinEnext1(co.front[ 3]);
	nc[ 3] := FnextEnext(nc[ 2]); 
	nc[ 4] := ClockSpinEnext1(co.front[ 8]);
	nc[ 5] := FnextEnext(nc[ 4]); 
	nc[ 6] := ClockSpinEnext1(co.front[15]);  
	nc[ 7] := FnextEnext(nc[ 6]);
	nc[ 8] := ClockSpinEnext1(co.front[24]);
	(* *)
	nc[ 9] := ClockSpinEnext1(co.front[ 1]);
	nc[10] := FnextEnext(nc[ 9]);
	nc[11] := ClockSpinEnext1(co.front[ 6]);
	nc[12] := FnextEnext(nc[11]);
	nc[13] := ClockSpinEnext1(co.front[13]);
	nc[14] := FnextEnext(nc[13]);
	nc[15] := ClockSpinEnext1(co.front[22]);
	(* *)
	nc[16] := ClockSpinEnext1(co.front[ 4]);
	nc[17] := FnextEnext(nc[16]);
	nc[18] := ClockSpinEnext1(co.front[11]);
	nc[19] := FnextEnext(nc[18]);
	nc[20] := ClockSpinEnext1(co.front[20]);
	(* *)
	nc[21] := ClockSpinEnext1(co.front[ 9]);
	nc[22] := FnextEnext(nc[21]);
	nc[23] := ClockSpinEnext1(co.front[18]);
	(* *)
	nc[24] := ClockSpinEnext1(co.front[16]);
      END
    END;
  IF cnum = 7 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext0(co.front[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext0(co.front[ 3]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.front[ 1]);
      (* *)
      nc[ 3] := ClockSpinEnext0(co.front[ 0]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext0(co.front[ 8]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.front[ 6]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext0(co.front[ 4]);
      (* *)
      nc[ 5] := ClockSpinEnext0(co.front[ 3]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext0(co.front[ 1]);
      (* *)
      nc[ 8] := ClockSpinEnext0(co.front[ 0]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext0(co.front[15]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.front[13]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext0(co.front[11]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext0(co.front[ 9]);  
      (* *)
      nc[ 7] := ClockSpinEnext0(co.front[ 8]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext0(co.front[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.front[ 4]);
      (* *)
      nc[12] := ClockSpinEnext0(co.front[ 3]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext0(co.front[ 1]);
      (* *)
      nc[15] := ClockSpinEnext0(co.front[ 0]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext0(co.front[24]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.front[22]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext0(co.front[20]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext0(co.front[18]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext0(co.front[16]);
      (* *)
      nc[ 9] := ClockSpinEnext0(co.front[15]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.front[13]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext0(co.front[11]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext0(co.front[ 9]);
      (* *)
      nc[16] := ClockSpinEnext0(co.front[ 8]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext0(co.front[ 6]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext0(co.front[ 4]);
      (* *)
      nc[21] := ClockSpinEnext0(co.front[ 3]);
      nc[22] := FnextEnext(nc[21]);  
      nc[23] := ClockSpinEnext0(co.front[ 1]);
      (* *)
      nc[24] := ClockSpinEnext0(co.front[ 0]);
    END
  END;
  IF cnum = 8 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext2(co.front[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext2(co.front[ 1]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.front[ 0]);
      (* *)
      nc[ 3] := ClockSpinEnext2(co.front[ 3]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext2(co.front[ 4]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.front[ 1]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext2(co.front[ 0]);
      (* *)
      nc[ 5] := ClockSpinEnext2(co.front[ 6]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext2(co.front[ 3]);
      (* *)
      nc[ 8] := ClockSpinEnext2(co.front[ 8]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext2(co.front[ 9]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.front[ 4]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext2(co.front[ 1]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext2(co.front[ 0]);  
      (* *)
      nc[ 7] := ClockSpinEnext2(co.front[11]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext2(co.front[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.front[ 3]);
      (* *)
      nc[12] := ClockSpinEnext2(co.front[13]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext2(co.front[ 8]);
      (* *)
      nc[15] := ClockSpinEnext2(co.front[15]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext2(co.front[16]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.front[ 9]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext2(co.front[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext2(co.front[ 1]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext2(co.front[ 0]);
      (* *)
      nc[ 9] := ClockSpinEnext2(co.front[18]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.front[11]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext2(co.front[ 6]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext2(co.front[ 3]);
      (* *)
      nc[16] := ClockSpinEnext2(co.front[20]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext2(co.front[13]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext2(co.front[ 8]);
      (* *)
      nc[21] := ClockSpinEnext2(co.front[22]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext2(co.front[15]);
      (* *)
      nc[24] := ClockSpinEnext2(co.front[24]);
    END
  END;
  IF cnum = 9 THEN
    IF order = 1 THEN
      nc[ 0] := Enext1(co.back[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := Enext1(co.back[ 3]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext1(co.back[ 0]);
      (* *)
      nc[ 3] := Enext1(co.back[ 1]);
    ELSIF order = 3 THEN
      nc[ 0] := Enext1(co.back[ 8]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext1(co.back[ 3]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := Enext1(co.back[ 0]);
      (* *)
      nc[ 5] := Enext1(co.back[ 6]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := Enext1(co.back[ 1]);
      (* *)
      nc[ 8] := Enext1(co.back[ 4]);
    ELSIF order = 4 THEN
      nc[ 0] := Enext1(co.back[15]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext1(co.back[ 8]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext1(co.back[ 3]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext1(co.back[ 0]);  
      (* *)
      nc[ 7] := Enext1(co.back[13]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := Enext1(co.back[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext1(co.back[ 1]);
      (* *)
      nc[12] := Enext1(co.back[11]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := Enext1(co.back[ 4]);
      (* *)
      nc[15] := Enext1(co.back[ 9]);
    ELSIF order = 5 THEN
      nc[ 0] := Enext1(co.back[24]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext1(co.back[15]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := Enext1(co.back[ 8]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := Enext1(co.back[ 3]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := Enext1(co.back[ 0]);
      (* *)
      nc[ 9] := Enext1(co.back[22]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext1(co.back[13]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := Enext1(co.back[ 6]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := Enext1(co.back[ 1]);
      (* *)
      nc[16] := Enext1(co.back[20]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := Enext1(co.back[11]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := Enext1(co.back[ 4]);
      (* *)
      nc[21] := Enext1(co.back[18]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := Enext1(co.back[ 9]);
      (* *)
      nc[24] := Enext1(co.back[16]);
    END
  END;
  IF cnum = 10 THEN
    IF order = 1 THEN
      nc[ 0] := Enext2(co.back[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := Enext2(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext2(co.back[ 1]);
      (* *)
      nc[ 3] := Enext2(co.back[ 3]);
    ELSIF order = 3 THEN
      nc[ 0] := Enext2(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext2(co.back[ 1]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := Enext2(co.back[ 4]);
      (* *)
      nc[ 5] := Enext2(co.back[ 3]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := Enext2(co.back[ 6]);
      (* *)
      nc[ 8] := Enext2(co.back[ 8]);
    ELSIF order = 4 THEN
      nc[ 0] := Enext2(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext2(co.back[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext2(co.back[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext2(co.back[ 9]);  
      (* *)
      nc[ 7] := Enext2(co.back[ 3]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := Enext2(co.back[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext2(co.back[11]);
      (* *)
      nc[12] := Enext2(co.back[ 8]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := Enext2(co.back[13]);
      (* *)
      nc[15] := Enext2(co.back[15]);
    ELSIF order = 5 THEN
      nc[ 0] := Enext2(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext2(co.back[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := Enext2(co.back[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := Enext2(co.back[ 9]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := Enext2(co.back[16]);
      (* *)
      nc[ 9] := Enext2(co.back[ 3]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext2(co.back[ 6]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := Enext2(co.back[11]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := Enext2(co.back[18]);
      (* *)
      nc[16] := Enext2(co.back[ 8]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := Enext2(co.back[13]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := Enext2(co.back[20]);
      (* *)
      nc[21] := Enext2(co.back[15]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := Enext2(co.back[22]);
      (* *)
      nc[24] := Enext2(co.back[24]);
    END
  END;    
  IF cnum = 11 THEN
    IF order = 1 THEN
      nc[ 0] := Enext0(co.back[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := Enext0(co.back[ 1]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext0(co.back[ 3]);
      (* *)
      nc[ 3] := Enext0(co.back[ 0]);
    ELSIF order = 3 THEN
      nc[ 0] := Enext0(co.back[ 4]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext0(co.back[ 6]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := Enext0(co.back[ 8]);
      (* *)
      nc[ 5] := Enext0(co.back[ 1]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := Enext0(co.back[ 3]);
      (* *)
      nc[ 8] := Enext0(co.back[ 0]);
    ELSIF order = 4 THEN
      nc[ 0] := Enext0(co.back[ 9]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext0(co.back[11]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext0(co.back[13]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext0(co.back[15]);  
      (* *)
      nc[ 7] := Enext0(co.back[ 4]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := Enext0(co.back[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext0(co.back[ 8]);
      (* *)
      nc[12] := Enext0(co.back[ 1]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := Enext0(co.back[ 3]);
      (* *)
      nc[15] := Enext0(co.back[ 0]);
    ELSIF order = 5 THEN
      nc[ 0] := Enext0(co.back[16]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext0(co.back[18]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := Enext0(co.back[20]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := Enext0(co.back[22]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := Enext0(co.back[24]);
      (* *)
      nc[ 9] := Enext0(co.back[ 9]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext0(co.back[11]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := Enext0(co.back[13]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := Enext0(co.back[15]);
      (* *)
      nc[16] := Enext0(co.back[ 4]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := Enext0(co.back[ 6]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := Enext0(co.back[ 8]);
      (* *)
      nc[21] := Enext0(co.back[ 1]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := Enext0(co.back[ 3]);
      (* *)
      nc[24] := Enext0(co.back[ 0]);
    END
  END;
  IF cnum = 12 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext0(co.right[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext0(co.right[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.right[ 1]);
      (* *)
      nc[ 3] := ClockSpinEnext0(co.right[ 3]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext0(co.right[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.right[ 1]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext0(co.right[ 4]);
      (* *)
      nc[ 5] := ClockSpinEnext0(co.right[ 3]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext0(co.right[ 6]);
      (* *)
      nc[ 8] := ClockSpinEnext0(co.right[ 8]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext0(co.right[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.right[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext0(co.right[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext0(co.right[ 9]);  
      (* *)
      nc[ 7] := ClockSpinEnext0(co.right[ 3]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext0(co.right[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.right[11]);
      (* *)
      nc[12] := ClockSpinEnext0(co.right[ 8]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext0(co.right[13]);
      (* *)
      nc[15] := ClockSpinEnext0(co.right[15]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext0(co.right[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.right[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext0(co.right[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext0(co.right[ 9]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext0(co.right[16]);
      (* *)
      nc[ 9] := ClockSpinEnext0(co.right[ 3]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.right[ 6]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext0(co.right[11]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext0(co.right[18]);
      (* *)
      nc[16] := ClockSpinEnext0(co.right[ 8]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext0(co.right[13]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext0(co.right[20]);
      (* *)
      nc[21] := ClockSpinEnext0(co.right[15]);
      nc[22] := FnextEnext(nc[21]);  
      nc[23] := ClockSpinEnext0(co.right[22]);
      (* *)
      nc[24] := ClockSpinEnext0(co.right[24]);
    END
  END;
  IF cnum = 13 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext1(co.right[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext1(co.right[ 3]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext1(co.right[ 0]);
      (* *)
      nc[ 3] := ClockSpinEnext1(co.right[ 1]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext1(co.right[ 8]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext1(co.right[ 3]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext1(co.right[ 0]);
      (* *)
      nc[ 5] := ClockSpinEnext1(co.right[ 6]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext1(co.right[ 1]);
      (* *)
      nc[ 8] := ClockSpinEnext1(co.right[ 4]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext1(co.right[15]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext1(co.right[ 8]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext1(co.right[ 3]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext1(co.right[ 0]);  
      (* *)
      nc[ 7] := ClockSpinEnext1(co.right[13]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext1(co.right[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext1(co.right[ 1]);
      (* *)
      nc[12] := ClockSpinEnext1(co.right[11]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext1(co.right[ 4]);
      (* *)
      nc[15] := ClockSpinEnext1(co.right[ 9]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext1(co.right[24]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext1(co.right[15]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext1(co.right[ 8]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext1(co.right[ 3]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext1(co.right[ 0]);
      (* *)
      nc[ 9] := ClockSpinEnext1(co.right[22]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext1(co.right[13]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext1(co.right[ 6]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext1(co.right[ 1]);
      (* *)
      nc[16] := ClockSpinEnext1(co.right[20]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext1(co.right[11]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext1(co.right[ 4]);
      (* *)
      nc[21] := ClockSpinEnext1(co.right[18]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext1(co.right[ 9]);
      (* *)
      nc[24] := ClockSpinEnext1(co.right[16]);
    END
  END;
  IF cnum = 14 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext2(co.right[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext2(co.right[ 1]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.right[ 3]);
      (* *)
      nc[ 3] := ClockSpinEnext2(co.right[ 0]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext2(co.right[ 4]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.right[ 6]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext2(co.right[ 8]);
      (* *)
      nc[ 5] := ClockSpinEnext2(co.right[ 1]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext2(co.right[ 3]);
      (* *)
      nc[ 8] := ClockSpinEnext2(co.right[ 0]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext2(co.right[ 9]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.right[11]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext2(co.right[13]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext2(co.right[15]);  
      (* *)
      nc[ 7] := ClockSpinEnext2(co.right[ 4]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext2(co.right[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.right[ 8]);
      (* *)
      nc[12] := ClockSpinEnext2(co.right[ 1]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext2(co.right[ 3]);
      (* *)
      nc[15] := ClockSpinEnext2(co.right[ 0]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext2(co.right[16]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.right[18]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext2(co.right[20]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext2(co.right[22]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext2(co.right[24]);
      (* *)
      nc[ 9] := ClockSpinEnext2(co.right[ 9]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.right[11]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext2(co.right[13]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext2(co.right[15]);
      (* *)
      nc[16] := ClockSpinEnext2(co.right[ 4]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext2(co.right[ 6]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext2(co.right[ 8]);
      (* *)
      nc[21] := ClockSpinEnext2(co.right[ 1]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext2(co.right[ 3]);
      (* *)
      nc[24] := ClockSpinEnext2(co.right[ 0]);
    END
  END;    
  IF cnum = 15 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext0(co.left[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext0(co.left[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.left[ 1]);
      (* *)
      nc[ 3] := ClockSpinEnext0(co.left[ 3]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext0(co.left[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.left[ 1]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext0(co.left[ 4]);
      (* *)
      nc[ 5] := ClockSpinEnext0(co.left[ 3]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext0(co.left[ 6]);
      (* *)
      nc[ 8] := ClockSpinEnext0(co.left[ 8]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext0(co.left[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.left[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext0(co.left[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext0(co.left[ 9]);  
      (* *)
      nc[ 7] := ClockSpinEnext0(co.left[ 3]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext0(co.left[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.left[11]);
      (* *)
      nc[12] := ClockSpinEnext0(co.left[ 8]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext0(co.left[13]);
      (* *)
      nc[15] := ClockSpinEnext0(co.left[15]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext0(co.left[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.left[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext0(co.left[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext0(co.left[ 9]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext0(co.left[16]);
      (* *)
      nc[ 9] := ClockSpinEnext0(co.left[ 3]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.left[ 6]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext0(co.left[11]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext0(co.left[18]);
      (* *)
      nc[16] := ClockSpinEnext0(co.left[ 8]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext0(co.left[13]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext0(co.left[20]);
      (* *)
      nc[21] := ClockSpinEnext0(co.left[15]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext0(co.left[22]);
      (* *)
      nc[24] := ClockSpinEnext0(co.left[24]);
    END
  END;
  IF cnum = 16 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext1(co.left[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext1(co.left[ 3]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext1(co.left[ 0]);
      (* *)
      nc[ 3] := ClockSpinEnext1(co.left[ 1]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext1(co.left[ 8]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext1(co.left[ 3]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext1(co.left[ 0]);
      (* *)
      nc[ 5] := ClockSpinEnext1(co.left[ 6]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext1(co.left[ 1]);
      (* *)
      nc[ 8] := ClockSpinEnext1(co.left[ 4]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext1(co.left[15]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext1(co.left[ 8]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext1(co.left[ 3]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext1(co.left[ 0]);  
      (* *)
      nc[ 7] := ClockSpinEnext1(co.left[13]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext1(co.left[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext1(co.left[ 1]);
      (* *)
      nc[12] := ClockSpinEnext1(co.left[11]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext1(co.left[ 4]);
      (* *)
      nc[15] := ClockSpinEnext1(co.left[ 9]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext1(co.left[24]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext1(co.left[15]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext1(co.left[ 8]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext1(co.left[ 3]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext1(co.left[ 0]);
      (* *)
      nc[ 9] := ClockSpinEnext1(co.left[22]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext1(co.left[13]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext1(co.left[ 6]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext1(co.left[ 1]);
      (* *)
      nc[16] := ClockSpinEnext1(co.left[20]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext1(co.left[11]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext1(co.left[ 4]);
      (* *)
      nc[21] := ClockSpinEnext1(co.left[18]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext1(co.left[ 9]);
      (* *)
      nc[24] := ClockSpinEnext1(co.left[16]);
    END
  END;    
  IF cnum = 17 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext2(co.left[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext2(co.left[ 1]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.left[ 3]);
      (* *)
      nc[ 3] := ClockSpinEnext2(co.left[ 0]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext2(co.left[ 4]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.left[ 6]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext2(co.left[ 8]);
      (* *)
      nc[ 5] := ClockSpinEnext2(co.left[ 1]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext2(co.left[ 3]);
      (* *)
      nc[ 8] := ClockSpinEnext2(co.left[ 0]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext2(co.left[ 9]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.left[11]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext2(co.left[13]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext2(co.left[15]);  
      (* *)
      nc[ 7] := ClockSpinEnext2(co.left[ 4]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext2(co.left[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.left[ 8]);
      (* *)
      nc[12] := ClockSpinEnext2(co.left[ 1]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext2(co.left[ 3]);
      (* *)
      nc[15] := ClockSpinEnext2(co.left[ 0]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext2(co.left[16]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.left[18]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext2(co.left[20]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext2(co.left[22]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext2(co.left[24]);
      (* *)
      nc[ 9] := ClockSpinEnext2(co.left[ 9]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.left[11]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext2(co.left[13]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext2(co.left[15]);
      (* *)
      nc[16] := ClockSpinEnext2(co.left[ 4]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext2(co.left[ 6]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext2(co.left[ 8]);
      (* *)
      nc[21] := ClockSpinEnext2(co.left[ 1]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext2(co.left[ 3]);
      (* *)
      nc[24] := ClockSpinEnext2(co.left[ 0]);
    END
  END;    
  IF cnum = 18 THEN
    IF order = 1 THEN
      nc[ 0] := Enext1(co.front[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := Enext1(co.front[ 3]);
      nc[ 1] := FnextEnext(nc[0]);   
      nc[ 2] := Enext1(co.front[ 0]);
      (* *)
      nc[ 3] := Enext1(co.front[ 1]);
    ELSIF order = 3 THEN
      nc[ 0] := Enext1(co.front[ 8]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext1(co.front[ 3]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := Enext1(co.front[ 0]);
      (* *)
      nc[ 5] := Enext1(co.front[ 6]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := Enext1(co.front[ 1]);
      (* *)
      nc[ 8] := Enext1(co.front[ 4]);
    ELSIF order = 4 THEN
      nc[ 0] := Enext1(co.front[15]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext1(co.front[ 8]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext1(co.front[ 3]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext1(co.front[ 0]);  
      (* *)
      nc[ 7] := Enext1(co.front[13]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := Enext1(co.front[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext1(co.front[ 1]);
      (* *)
      nc[12] := Enext1(co.front[11]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := Enext1(co.front[ 4]);
      (* *)
      nc[15] := Enext1(co.front[ 9]);
    ELSIF order = 5 THEN
      nc[ 0] := Enext1(co.front[24]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext1(co.front[15]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := Enext1(co.front[ 8]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext1(co.front[ 3]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := Enext1(co.front[ 0]);
      (* *)
      nc[ 9] := Enext1(co.front[22]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext1(co.front[13]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := Enext1(co.front[ 6]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := Enext1(co.front[ 1]);
      (* *)
      nc[16] := Enext1(co.front[20]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := Enext1(co.front[11]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := Enext1(co.front[ 4]);
      (* *)
      nc[21] := Enext1(co.front[18]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := Enext1(co.front[ 9]);
      (* *)
      nc[24] := Enext1(co.front[16]);
    END
  END;
  IF cnum = 19 THEN
    IF order = 1 THEN
      nc[ 0] := Enext0(co.front[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := Enext0(co.front[ 1]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext0(co.front[ 3]);
      (* *)
      nc[ 3] := Enext0(co.front[ 0]);
    ELSIF order = 3 THEN
      nc[ 0] := Enext0(co.front[ 4]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext0(co.front[ 6]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := Enext0(co.front[ 8]);
      (* *)
      nc[ 5] := Enext0(co.front[ 1]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := Enext0(co.front[ 3]);
      (* *)
      nc[ 8] := Enext0(co.front[ 0]);
    ELSIF order = 4 THEN
      nc[ 0] := Enext0(co.front[ 9]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext0(co.front[11]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext0(co.front[13]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext0(co.front[15]);  
      (* *)
      nc[ 7] := Enext0(co.front[ 4]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := Enext0(co.front[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext0(co.front[ 8]);
      (* *)
      nc[12] := Enext0(co.front[ 1]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := Enext0(co.front[ 3]);
      (* *)
      nc[15] := Enext0(co.front[ 0]);
    ELSIF order = 5 THEN
      nc[ 0] := Enext0(co.front[16]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext0(co.front[18]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := Enext0(co.front[20]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := Enext0(co.front[22]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := Enext0(co.front[24]);
      (* *)
      nc[ 9] := Enext0(co.front[ 9]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext0(co.front[11]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := Enext0(co.front[13]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := Enext0(co.front[15]);
      (* *)
      nc[16] := Enext0(co.front[ 4]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := Enext0(co.front[ 6]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := Enext0(co.front[ 8]);
      (* *)
      nc[21] := Enext0(co.front[ 1]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := Enext0(co.front[ 3]);
      (* *)
      nc[24] := Enext0(co.front[ 0]);
    END
  END; 
  IF cnum = 20 THEN
    IF order = 1 THEN
      nc[ 0] := Enext2(co.front[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := Enext2(co.front[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext2(co.front[ 1]);
      (* *)
      nc[ 3] := Enext2(co.front[ 3]);
    ELSIF order = 3 THEN
      nc[ 0] := Enext2(co.front[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := Enext2(co.front[ 1]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := Enext2(co.front[ 4]);
      (* *)
      nc[ 5] := Enext2(co.front[ 3]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := Enext2(co.front[ 6]);
      (* *)
      nc[ 8] := Enext2(co.front[ 8]);
    ELSIF order = 4 THEN
      nc[ 0] := Enext2(co.front[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext2(co.front[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext2(co.front[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext2(co.front[ 9]);  
      (* *)
      nc[ 7] := Enext2(co.front[ 3]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := Enext2(co.front[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext2(co.front[11]);
      (* *)
      nc[12] := Enext2(co.front[ 8]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := Enext2(co.front[13]);
      (* *)
      nc[15] := Enext2(co.front[15]);
    ELSIF order = 5 THEN
      nc[ 0] := Enext2(co.front[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := Enext2(co.front[ 1]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := Enext2(co.front[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := Enext2(co.front[ 9]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := Enext2(co.front[16]);
      (* *)
      nc[ 9] := Enext2(co.front[ 3]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := Enext2(co.front[ 6]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := Enext2(co.front[11]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := Enext2(co.front[18]);
      (* *)
      nc[16] := Enext2(co.front[ 8]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := Enext2(co.front[13]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := Enext2(co.front[20]);
      (* *)
      nc[21] := Enext2(co.front[15]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := Enext2(co.front[22]);
      (* *)
      nc[24] := Enext2(co.front[24]);
    END
  END;    
  IF cnum = 21 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext1(co.back[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext1(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext1(co.back[ 3]);
      (* *)
      nc[ 3] := ClockSpinEnext1(co.back[ 1]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext1(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext1(co.back[ 3]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext1(co.back[ 8]);
      (* *)
      nc[ 5] := ClockSpinEnext1(co.back[ 1]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext1(co.back[ 6]);
      (* *)
      nc[ 8] := ClockSpinEnext1(co.back[ 4]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext1(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext1(co.back[ 3]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext1(co.back[ 8]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext1(co.back[15]);  
      (* *)
      nc[ 7] := ClockSpinEnext1(co.back[ 1]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext1(co.back[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext1(co.back[13]);
      (* *)
      nc[12] := ClockSpinEnext1(co.back[ 4]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext1(co.back[11]);
      (* *)
      nc[15] := ClockSpinEnext1(co.back[ 9]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext1(co.back[ 0]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext1(co.back[ 3]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext1(co.back[ 8]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext1(co.back[15]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext1(co.back[24]);
      (* *)
      nc[ 9] := ClockSpinEnext1(co.back[ 1]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext1(co.back[ 6]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext1(co.back[13]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext1(co.back[22]);
      (* *)
      nc[16] := ClockSpinEnext1(co.back[ 4]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext1(co.back[11]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext1(co.back[20]);
      (* *)
      nc[21] := ClockSpinEnext1(co.back[ 9]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext1(co.back[18]);
      (* *)
      nc[24] := ClockSpinEnext1(co.back[16]);
    END
  END;    
  IF cnum = 22 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext2(co.back[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext2(co.back[ 1]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.back[ 0]);
      (* *)
      nc[ 3] := ClockSpinEnext2(co.back[ 3]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext2(co.back[ 4]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext2(co.back[ 1]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext2(co.back[ 0]);
      (* *)
      nc[ 5] := ClockSpinEnext2(co.back[ 6]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext2(co.back[ 3]);
      (* *)
      nc[ 8] := ClockSpinEnext2(co.back[ 8]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext2(co.back[ 9]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.back[ 4]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext2(co.back[ 1]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext2(co.back[ 0]);  
      (* *)
      nc[ 7] := ClockSpinEnext2(co.back[11]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext2(co.back[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.back[ 3]);
      (* *)
      nc[12] := ClockSpinEnext2(co.back[13]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext2(co.back[ 8]);
      (* *)
      nc[15] := ClockSpinEnext2(co.back[15]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext2(co.back[16]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext2(co.back[ 9]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext2(co.back[ 4]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext2(co.back[ 1]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext2(co.back[ 0]);
      (* *)
      nc[ 9] := ClockSpinEnext2(co.back[18]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext2(co.back[11]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext2(co.back[ 6]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext2(co.back[ 3]);
      (* *)
      nc[16] := ClockSpinEnext2(co.back[20]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext2(co.back[13]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext2(co.back[ 8]);
      (* *)
      nc[21] := ClockSpinEnext2(co.back[22]);
      nc[22] := FnextEnext(nc[21]);
      nc[23] := ClockSpinEnext2(co.back[15]);
      (* *)
      nc[24] := ClockSpinEnext2(co.back[24]);
    END
  END;
  IF cnum = 23 THEN
    IF order = 1 THEN
      nc[ 0] := ClockSpinEnext0(co.back[ 0]);
    ELSIF order = 2 THEN
      nc[ 0] := ClockSpinEnext0(co.back[ 3]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.back[ 1]);
      (* *)
      nc[ 3] := ClockSpinEnext0(co.back[ 0]);
    ELSIF order = 3 THEN
      nc[ 0] := ClockSpinEnext0(co.back[ 8]);
      nc[ 1] := FnextEnext(nc[0]);
      nc[ 2] := ClockSpinEnext0(co.back[ 6]);
      nc[ 3] := FnextEnext(nc[2]);
      nc[ 4] := ClockSpinEnext0(co.back[ 4]);
      (* *)
      nc[ 5] := ClockSpinEnext0(co.back[ 3]);
      nc[ 6] := FnextEnext(nc[5]);
      nc[ 7] := ClockSpinEnext0(co.back[ 1]);
      (* *)
      nc[ 8] := ClockSpinEnext0(co.back[ 0]);
    ELSIF order = 4 THEN
      nc[ 0] := ClockSpinEnext0(co.back[15]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.back[13]);
      nc[ 3] := FnextEnext(nc[ 2]);
      nc[ 4] := ClockSpinEnext0(co.back[11]);
      nc[ 5] := FnextEnext(nc[ 4]);
      nc[ 6] := ClockSpinEnext0(co.back[ 9]);  
      (* *)
      nc[ 7] := ClockSpinEnext0(co.back[ 8]);
      nc[ 8] := FnextEnext(nc[ 7]);
      nc[ 9] := ClockSpinEnext0(co.back[ 6]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.back[ 4]);
      (* *)
      nc[12] := ClockSpinEnext0(co.back[ 3]);
      nc[13] := FnextEnext(nc[12]);
      nc[14] := ClockSpinEnext0(co.back[ 1]);
      (* *)
      nc[15] := ClockSpinEnext0(co.back[ 0]);
    ELSIF order = 5 THEN
      nc[ 0] := ClockSpinEnext0(co.back[24]);
      nc[ 1] := FnextEnext(nc[ 0]);
      nc[ 2] := ClockSpinEnext0(co.back[22]);
      nc[ 3] := FnextEnext(nc[ 2]); 
      nc[ 4] := ClockSpinEnext0(co.back[20]);
      nc[ 5] := FnextEnext(nc[ 4]); 
      nc[ 6] := ClockSpinEnext0(co.back[18]);  
      nc[ 7] := FnextEnext(nc[ 6]);
      nc[ 8] := ClockSpinEnext0(co.back[16]);
      (* *)
      nc[ 9] := ClockSpinEnext0(co.back[15]);
      nc[10] := FnextEnext(nc[ 9]);
      nc[11] := ClockSpinEnext0(co.back[13]);
      nc[12] := FnextEnext(nc[11]);
      nc[13] := ClockSpinEnext0(co.back[11]);
      nc[14] := FnextEnext(nc[13]);
      nc[15] := ClockSpinEnext0(co.back[ 9]);
      (* *)
      nc[16] := ClockSpinEnext0(co.back[ 8]);
      nc[17] := FnextEnext(nc[16]);
      nc[18] := ClockSpinEnext0(co.back[ 6]);
      nc[19] := FnextEnext(nc[18]);
      nc[20] := ClockSpinEnext0(co.back[ 4]);
      (* *)
      nc[21] := ClockSpinEnext0(co.back[ 3]);
      nc[22] := FnextEnext(nc[21]); 
      nc[23] := ClockSpinEnext0(co.back[ 1]);
      (* *)
      nc[24] := ClockSpinEnext0(co.back[ 0]);
    END
  END;    
  RETURN nc;  
  END PairsOnFrontier;


BEGIN
END Refine.

(**************************************************************************)
(*                                                                        *)
(* Copyright (C) 2000     Universidade Estadual de Campinas (UNICAMP)     *)
(*                                                                        *)
(* Authors:                                                               *)
(*   L. P. Lozada  & J. Stolfi   - UNICAMP <lozada@dcc.unicamp.br>        *)
(*                                                                        *)
(* This file can be freely used, distributed, and modified, provided that *)
(* this copyright and authorship notice is included in every copy or      *)
(* derived version.                                                       *)
(*                                                                        *)
(* DISCLAIMER: This software is offered ``as is'', without any guarantee  *)
(*   as to fitness for any particular purpose.  Neither the copyright     *)
(*   holder nor the authors or their employers can be held responsible    *)
(*   for any damages that may result from its use.                        *)
(*                                                                        *)
(* Last edited on 2001-05-21 01:39:20 by stolfi                           *)
(**************************************************************************)