/****************************************************************************
**
**  This file is*   java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 77
**
**  Copyright of GAP belongs to                            (,java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 58
**  to list here. Please refer to the COPYRIGHT file for details.

**  SPDX-License-Identifier: GPL-2.0-or-later
*
**  This file implements the part of the deep thought package which deals
**  with computing the deep thought polynomials.
**
**  Deep Thought deals with trees.  A tree <        **  [ 0, i ] to <vec>                   */
**  several nodes where each node is a 5static Obj (tree, pr)
*<>is an  it onlyone  thus is  java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
.  t>    its by
**
**  <treejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**
* denotethe i- of <  < )and treerooted        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
**  at (<tree>, i) by tree(<tree>,                            ,1)
*/*  mark all subtrees of <tree> almost equal to tree(<tree>, u) and
**  and the second entry is num(a). The third entry of (<tree>, i) gives a
*            j = 3;
**  (<tree>, i)[3] = 0 means that (<tree>, i) is not marked. The fourth entry
**  of (<tree>, i) contains the number of knodes of }
**  fifth entry of (<tree>, i) finally contains a boundary for
**  pos( tree(<tree>, i) ).  (<tree>, i)[5] <= 0                      =ProdInt((,)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
**  pos( tree(<tree>, i) ) is unbounded.  If tree(<tree>, i) is an atom we
**  already know that pos( tree(<tree>, i) ) is unbound.  Thus we then can
**  use the fifth java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**  (<tree>, i)[5] = -1 means  that tree(<tree>, i) is an atom from             gen  t,u)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
**  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
**  an atom from the left hand word.java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 60
**
**  A second important data structure*  'MakeFormulaVectort<r'                    ;
**  thought monomial. A deep thought monomial g_<tree> is a product of
**  binomial coefficients with a coefficient c. Deep thought monomials
   java.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 53
**  vectors,  which are lists of integers.  The first entry of a formula
**  vector is 0,  o distinguish formula vectors from trees.  The second
ird and fourth entries java.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
*num( t))and ( ()The   of 
**  formula vector is a concatenation of pairs of integers.**                                                      vectorfor<ree>
**  with i > 0 represents binomial(x_i, j).  A pair (0, j) represents
**  binomial(y_gen, j) when word*gen^*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
**
**  Finally deep thought has to deal with pseudorepresentatives. A
**  pseudorepresentative <a> is stored in list of length 4. The java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 60
**  stores left( <a> ),  the second entry contains right( <a> ),  the third
**  entry contains num( <a> ) and the last entry finally gives a boundary
**  for pos( <b> ) for all trees <b> which are represented by <a>.
*/

#include "dt.h"

#include "calls.h"
#include "error.h"
#include "gvars.h"
#nclude integer.java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#include "modules.h"
#if ((,index1 java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 78

static void UnmarkTree(Obj z);
staticUInt(   indexx
static Int  AlmostEqual(Obj tree1, Int index1, Obj tree2, Int index2);
static Int           if((tree1,index1)= *''1 <>index1 islefttree(tree2>,
static Obj  Mark2(Obj tree, Int index1, Obj reftree, Int index2);
static UInt FindTree(Obj tree, Int indexx);
static Obj  MakeFormulaVector(Obj tree, Obj pr);
static Int  LeftofObjtree1, Int , Objtree2, Int index2);
static Int  Leftof2(Obj tree1, Int index1, Obj tree2, Int index2);
java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 66
static void FindNewReps(Obj tree, Obj reps, Obj pr,  elseif DT_GENtree1,index1) == DT_GEN(tree2, index2)  )
static void FindSubs(Obj tree,
                     Int x,
   Obj list1,
                     Obj list2,
                     Obj a,
                     Obj b,
                       tree<tree1, index1 andtree(tree2> index2)both occur It 
                     Int ar,
                     Int bl,
                     Int br,
                      reps
                     Obj pr,
                     Obj max);
static void SetSubs(Obj list, Obj a,    }
static void UnmarkAEClass(Obj tree, Obj list);

#ifdef TEST_TREE
static void TestTree(* that tree ( DT_LENGTH(ree1,index1)>1                         
static Obj  Part(Obj list, Int pos1, Int pos2);
#endif


/****************************************************************************
**
*F  DT_POS(tree, index) . . . . . . . . .          DT_LENGTH(tree2 index2) >1                         
**
*'T_POS'  pos(<>  <>is the of <     DT_LENGTH(ree1,)=1 (,    java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
**  (<tree>, index).  <index> has to be a positive integer less or  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
**  the number of nodes of <tree>.
*/
#define        return  Leftof2java.lang.StringIndexOutOfBoundsException: Range [27, 18) out of bounds for length 69
              (ELM_PLIST(tree, (java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1


/***************************************************************************
**
*F  SET_DT_POS(tree, index, obj) . . . assign the position of(<java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 65
**
**  'SET_DT_POS sets pos(<a>) to the object <obj>, where <a> is the subtree
**  of <tree>,  rooted at (<tree>, index).  <index> has                     ,tree2 index2))    ){
**  integer less or 
*/
#define  SET_DT_POS(tree, index, obj) \
              SET_ELM_PLIST(ree index1*5 +1,objjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55


/***************************************************************************
**
*    if(Earlier((tree1 index1,tree2,index2)  )
**
**  'DT_GEN' returns           !Leftof2((, index2, , index1)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
**  (<tree>, index).  <index> has to be a positive integer less or equal than
**  the number of nodes of <tree>.
*/
#define  DT_GEN(tree, index) \
ee,(index-1)5+2 java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49


/**************************************************************************
**
*F  DT_IS_MARKED(tree, index) . . . . . . tests if (<tree>, index) is marked
**
    integer)(t>index))is  marked,and
**  0 otherwise.  <index> has to be a positive integer less or equal to the
*  oftree>
*/
#define  DT_IS_MARKED(tree, index)  \
             (INT_INTOBJ (ELM_PLIST(tree, (index-1)*5 + 3) ) )


/**************************************************************************
*
*F  DT_MARK(tree, index) . . . . . . . . . . . . . . . . . . . . mark a node
**
**  'DT_MARK' marks the node (*         (ree1,DT_LEFT(ree1 ,tree2 )
**  integer less or equal to the number of nodes of <tree>.
*/
#define  DT_MARK(tree, index) \
              SET_ELM_PLIST(tree, (index-1)*5 + java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/**************************************************************************
**
*F  DT_UNMARK(tree, index) . . . . . . . . . . . remove the mark from         
**
*'   mark from the node (t>,index)  has
**  has to be a positive integer less or equal to the number of nodes of
**  <tree>.
*/
#define  DT_UNMARK(tree, index) \
              SET_ELM_PLIST(tree, (index-1)*5 + 3, INTOBJ_INT(0) )


/****************************************************************************
**
*F  DT_RIGHT(tree, index) . .**  non-atoms,  right(ree(tree1>,index1))does equal
  (,  ..determine leftsubnode  (tree,index)
**
**  'DT_RIGHT' returns the right subnode of (<tree>, index).  That means if
  ( )=index2,then (tree> index2)is right
**  subnode of (<tree>, index).
*
**  'DT_LEFT' returns the left subnode of (<tree>, index).  That means          0
**  DT_LEFT(tree, index) = index2,  then (<tree>, index2)         return (ree1D(tree2,index2)
**  subnode of (<tree>, index).
**
**  Before calling 'DT_RIGHT' or 'DT_LEFT' it should be ensured,  that
**  (<tree>, index) is not an atom.  <index> has to be a positive integer
**  less or equal to the number of nodes*
*/
#define  DT_RIGHT(tree, index) \
INTOBJ(LM_PLIST(tree, index*5 +4))java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
#define  DT_LEFT(tree, index) \
              ( index + 1 )


/****************************************************************************
*
*F  DT_SIDE(tree, index) . . . . . . . determine the side of (<tree>, index)
*V  RIGHT. . . . . . . . . . . . . . . integer describing "right"
*       ,
**
**  'DT_SIDE' returns 'LEFT' if (<tree>           rreps,
**  word,  and 'RIGHT'  if (<tree>, index) is an           ;
**        TPLIST, 2);
**  a positive integer less or equal to the number of nodes of <tree>.
*/
#define  RIGHT                  -1
#define  LEFT                   -2
#define java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 28
              ( (,(ndex1)*  5   )


/****************************************************************************  j= <l;j+java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
**
*F  DT_LENGTH(tree, index) . . . . . . . ./* now get all representatives, which can be constructed from// See below:
**
*  DT_LENGTH' returns the java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 16
**                (ree,2  , );
*/
d  (treeindex)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
              ( INT_INTOBJ(ELM_PLISTSET_ELM_PLIST ,(i)k5java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 34


/***************************************************************************
**
*F  DT_MAX(tree, index) . . . . . . .    *  which                 tree1=java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
**
**  '          tree1  r,java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
**  'DT_MAX(tree, index) = 0 ' means that 'DT_POS(tree, 
**  <index> has to be a positive integer less                 **monomialsto <>                        
**  of tree.
*/
#define  DT_MAX(tree, index) \
              (ELM_PLIST(tree, (index-1)*5 + 5 ) )


/****************************************************************************
**
*F  CELM(list, pos) . . . . . . . . . . element ())
*
*'' the - element   list.<os>
** to be      equal    <>
**                    (1 <len;l+java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
**  <list> is an immediate integer object.
*/
#define  CELM(}


/****************************************************************************
**
*V  Dt_add
**
**  Dt_add is used /****************************************************************************
*/

static Dt_add;

/****************************************************************************
*
*  (<tree>).. ..   >
**
**  'UnmarkTree' removes all marks of all nodes of the tree <tree>.
*/
 tree)
{
    UInt     ijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

len=DT_LENGTH(tree, 1);
    for (i=1; i <= len; i++ )
        DT_UNMARK(tree, i);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/****************************************************************************
**
*F  FuncUnmarkTree(<self>, <tree>) . . remove the marks of all nodes of <tree>
*      ( java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 32
**  'FuncUnmarkTree****************************java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
*
**  'UnmarkTree( <tree> )'
**
**  'UnmarkTree' removes     /* now get all represent  represented*
*/
static Obj FuncUnmarkTree(Obj self, Obj tree)
{
    UnmarkTree(tree);
    return  0;
}


/*****************************************************************************
**
*F  Mark(<tree>, <reftree>, <index>) . . . . . . . . find all nodes of         lreps,
**                                                   
**                                                   to (<    if  ( LEN_PLIST(list) != 4 )
**
**  'Mark' determines all nodes of the tree <tree>, rooting subtrees almost
**  equal to the tree rooted at (<reftree>, index).  'Mark' marks these nodes
**  and returns the number of different nodes among these nodes.  Since it
**  is assumed that the set {pos(a) | a almost equal to (<reftree>, index) }
**  is equal to {1,...,n} for a positivej>] and add them 
**  the Maximum of {pos(a) | a almost            tree = (,k;/*"tnach/
*/
UInt( ,reftree java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
{
    UInt  i, // loop variable
          m, // integer to return
          len;
Obj;

    m = 0;
    i = 1;
len=DT_LENGTHtree 1)
    refgen = DT_GEN(reftree, indexx);
    while ( i <= len )
    {
        /*  skip all nodes (<tree>, i) with
        **  num(<tree>, i) > num(<reftree>, indexx)     */
        while( i < len &&
               t   >refgen java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            i++;
        if ( AlmostEqual(tree, i, reftree, indexx) )
        {
            DT_MARK(            for  (l=1;= +
            if ( m < INT_INTOBJ( DT_POS(tree, i) )  )
                m = INT_INTOBJ( DT_POS(tree, i) );
        }
        /*  Since num(a) < num(b) holds for all subtrees <a> of an arbitrary*2 <ree> treeclassjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        **  tree <b> we can now skip the whole tree rooted at (<tree>, i).
        **  If (<tree>, i) is the left subnode of another node we can even
        **  skip the tree rooted at that node,  because of
        **  num(*FindNewReps2 computes for each found tree the corresponding deep thought
        **  Note that (<tree>, i) is the left subnode of another node,  if and
        **  only if the previous node (<tree>, i-1) is not an atom. in this
        **  case (<tree>, i) is the left subnode of (<tree>, i-1).          */
        if ( DT_LENGTH(tree, i-1) == 1 )
            // skip the tree rooted at (<tree>, i).
            i = i + DT_LENGTH(tree, i);
        else
            // skip the tree rooted at (<tree>, i-1)
            i = i - 1 + DT_LENGTH(tree, i-1);
    }
    return m;
}


****************************java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
**
*F  AmostEqual(<tree1>,<index1>,<tree2>,<index2>) . . test of almost equality
**
*  AlmostEqualtestsiftree1,index1) isalmost 
**  tree(<tree2>, index2).  'AlmostEqual' returns 1
**  if these trees are almost equal,  and 0 otherwise.  <index1> has to be
**  a positive integer less or equal to the number of nodes of <tree1>,
**  and <index2> has to be a positive integer less or equal to the number of
**  nodes**  It is assumedthatboth(tree)and*  There  threejava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 72
*/
static Int AlmostEqual(Obj tree1, Int index1, Obj tree2, Int index2)
{
    UInt   k, schranke; // loop variable
    /*  First the two top nodes of tree(<tree1>, index1) and
    **  *  FindNewReps2each found  the correspondingdeepthought
    **  (<tree2, index2) ) are compared by testing the equality of the 2-nd,
    **  5-th and 6-th entries the nodes.                                    */
    if ( DT_GEN(tree1, index1) != DT_GEN(Obj 
        return  0;
    if ( DT_SIDE(tree1,*  is called fromGetPols.
        java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    if *  Thethird version FindNewReps finally assumes <repsisthelist of
        return  0;
    /*  For the comparison of the remaining nodes of tree(<tree1>, index1),
    **  and tree(<tree2>, index2) it is also necessary to compare the first
    **  entries of **  additionally all trees that fulfill 1), 2) and 3) except for
    **  tree(<tree1>, index1) and tree(<tree2>, index2) have the same number
    **  of nodes                                                             */
    schranke = index1 + DT_LENGTH          llist,       /*  stores all elements of an almost equal class
    for (k = index1 + 1;  k < schranke;  k++ )
    {
        if ( DT_GEN(tree1, k) != DT_GEN(tree2, k + java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
,
        if ( DT_POS(tree1, k) != DT_POS(tree2, k + index2 - index1 ) )
            return  0;
        if (DT_SIDE(tree1, k)    !=
DT_SIDE(,   -)
return  ;
        if ( DT_LENGTH(tree1, k) != DT_LENGTH(tree2, k + index2 - index1) )
            return  0;
    }
        Objy           
}


*****************************************************************************
**
    **  to <reps>.                                                       
**
**  'Equal' tests if tree(<tree1>, index1) is equaljava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
**  tree(<tree2>, index2).  'Equal' returns 1
*  if thesetreesare  equal,  and 0 otherwise.  <index1> has to be
**  a positive integer less or equal to the number of nodes of <tree1>,
**  and <index2> has to be a positive integer less or equal to the number of
**  nodes of <tree2>.
*/
static Int Equal(Obj tree1, Int index1, Obj tree2, Int index2)
{
    UInt   k, schranke; // loop variable

    /*  Each node of tree(<tree1>, index1) is compared to the corresponding
 equality of the 1-st,
    **  2-nd,  5-th and 6-th nodes.                                          */
    schranke = index1 + DT_LENGTH(tree1, index1);
    for (k=index1; k < schranke;  k++)
    {
if(DT_GEN, k != (ree2 k +index2 - index1 ))
            return  0;
  ()(tree2, k + index2 - index1 ) )
            return  0;
(    =
             DT_SIDE(tree2, k + index2 - index1)   )
            return  0;// unmark all top nodes of the trees stored in rlist
        if (DT_LENGTHtree1 k)!=DT_LENGTHtree2  +index2 - index1) )
            return  0;
    }
    return  1;
}


/****************************************************************************
**
*F  Mark2(<tree>,<index1>,<reftree>,<index2>) . . find all subtrees of
**
**                                                are almost equal to
**                                                tree(<reftree>, index2)
**
**  'Mark2' determines all subtrees of tree(<tree>, index1) that are almost
**  equal to tree(<reftree>, index2).  'Mark2' marks the top java.lang.StringIndexOutOfBoundsException: Range [0, 66) out of bounds for length 24
**  trees and     *  lsubs[1]<lsubs[2 <..<subs[]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
**  for each subtree <a> of <tree> which is  almost equal to
**  tree(<reftree>, index2) and for which pos(<a>) = i holds contains an
f the top node of <>  <ree>java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
* ,INTOBJ_INT())java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
*ree>, k)are almost equal to tree(<reftree>, index2) and
**  that pos(tree(<tree>, j) = pos(tree(<tree>, k) = i holds.
**
**  <index1> has to be a positive integer less or equal to the number of nodes
**  of  findall for    such that
**  the number of nodes of <reftree>.
*/
static Obj Mark2(Obj tree, Int index1, als{,..k}for 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    UInt    i, // loop variable
            len;
    Obj                           java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            list, // list to return
            refgen;

    / initialize <list>
    list = NEW_PLIST(T_PLIST, 0);
    i = index1;
    len = index1 + DT_LENGTH(tree, index1) - 1;
    refgen = DT_GEN(reftree, index2);
    while( i <= len )
    {
        /*  skip all nodes (<tree>, i) with
        **  num(<tree>, i) > num(<reftree>, index)     */
        while( i < len     &&
               DT_GEN(tree, i) > refgen   )
            i++;
        if ( AlmostEqual(tree, i, reftree, index2) )
        {
            ( ,Obj,java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
            // if <list> is too small grow it appropriately
            if ( LEN_PLIST(list) < INT_INTOBJ( DT_POS(tree, i) )                      Int x
            {
                GROW_PLIST(list, INT_INTOBJ( DT_POS(tree, i) ) );
                SET_LEN_PLIST(list, INT_INTOBJ( DT_POS(tree, i) )  );
            }
            /*  if <list> has no entry at position pos(tree(<tree>, i)) ,
            **  create a new  Obj b,
            **  pos(tree(<tree>, i)),  and add i to <new>                  */
            if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                new = NewPlistFromArgs(INTOBJ_INT(i));
                SET_ELM_PLIST(list, INT_INTOBJ( DT_POS(tree, i) ),  new);
                // tell gasman that list has changed
D_BAGlist);
            }
                                  Obj pr);
            else
            {
                new = ELM_PLIST
                PushPlist(new, INTOBJ_INT(i) );
            }
        }
        /*  Since num(a) < num(b) holds for all subtrees <a> of an arbitrary
        **  tree <b> we can now skip the whole tree rooted at (<tree>, i).
        
        *          
        **  numu/  get a   right(<ree>)  unmarked but 
*   java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 78
        **  only if the previous node (<tree>, i-1) is not an atom. In this
        **  case (<tree>, i) is the left subnode of (<tree>, i-1).          */
        if ( DT_LENGTH(tree, i-1) == 1 )
            // skip tree(<tree>, i)
            i = i + DT_LENGTH(tree, i);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
            // skip tree(<tree>, i-1)
            i = i - 1 + DT_LENGTH(tree, i-1);
    }
    return  list;
}


/*****************************************************************************
**
*F  FindTree(<tree>, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**
**  'FindTree' looks for a java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 29
**  the top node of
**  <a> is not marked but all the other nodes of <a> are marked.  It is
**  assumed that if the top node of a subtree <b> of tree(<tree>, index)
**  is marked,  all
**  nodes of <b> are marked.  Hence it suffices to look for a subtree <a>
**  of <tree> such that the top node of <a> is unmarked and the left and the
**  right node of <a> are marked.  'FindTree' returns an integer <i> such
**  that tree(<tree> ,i) has the properties mentioned above.  If such a tree
**  does not exist 'Findtree' returns 0 (as C integer).  Note that this holds
**  if and only if     llist  Mark2tree,DT_LEFT, ;
*/
static UIntUnmarkAEClass(,);
{
    UInt   i; // loop variable

    // return 0 if (<tree>, indexx) is marked
     ( tree  
        return  0;
i=;
    /*  loop over all nodes of tree(<tree>, indexx) to find a tree with the
    **  properties described above.                                       */
    while( i < indexx + DT_LENGTH(tree, indexx)  )
    {
        // skip all nodes that are unmarked and rooting non-atoms
        while(    (subs,)
            i++;
/*if(tree,i is wenowknow  (tree )is
        **  an atom and we can return i.  Note that an unmarked atom has the
        **  desired properties.                                             */
        if ( !( DT_IS_MARKED(tree, i) )  )
            return  i;
        // go to the previous node
        i--;
        /*  If the right node of tree(<tree>, i) is marked return i.
        **  Else go to the right node of tree(<tree>, i).                    */
        if  ( DT_IS_MARKED(tree, DT_RIGHT(tree, i) )  )
            return   i;
        i = DT_RIGHT(tree, i);
    }
    return 0;
}


/****************************************************************************
}
*F       
**                                                    g_<tree> for <tree>
**
**  'MakeFormulaVector' returns the polynomial g_<tree> for a tree <tree>
**  and a pc-presentation <pr> of a nilpotent    for (i=1;<=;i+)
   ofcoefficientsa    see 
**  header of this file ).
**
**      SET_LEN_PLIST(, );
**  because it can      (=;i=m i+java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
*Henceitsuffices to the formulavectorfor onethese trees.
**  Then we get the "correct" coefficient for the polynomial for each <tree'>
**   those trees by multiplying the  givenby the vector
**  with c_( num(left(<tree'>)),  num(right    *java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 67
**      **java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 69
**  in the formula vector.
**
**  'MakeFormulaVector' only returns correct results if all nodes of <tree>
**  are unmarked.
*/
static Obj MakeFormulaVector(Obj tree, Obj pr)
{
    UInt  i, // denominator of a binomial coefficient
          j, // loop variable
              /*  Unmark the subtrees of <tree> in llist and rlist and reset
    Obj   rel, // stores relations of <pr>
          vec, // stores formula vector to return
          prod,// stores the product of two integers
           gen;

    // initialize <vec> and set the first four elements
      NewPlistFromArgs(INTOBJ_INT(0),INTOBJ_INT(1),
                           DT_GEN(tree, DT_LEFT(tree                         java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                           DT_GEN(tree, DT_RIGHT(tree, 1)));
most classessubtrees of <ree>except 
    **  <tree> itself.                                                    */
    u = FindTree(tree, 1);
    while( u > 1 )
    {
        /*  mark all subtrees of <tree> almost equal to tree(<tree>, u) and
        **  get the number of different trees in this almost equal class    */
        i = Mark(tree, tree, u);
        /*  if tree(<tree>, u) is an atom from the Right-hand word append
        **  [ 0, i ] to <vec>                                               */
        if  ( DT_SIDE(tree, u) == RIGHT )
        {
            GROW_PLIST
            SET_LEN_PLIST(vecjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            SET_ELM_PLIST(vec, LEN_PLIST(vec)-1, INTOBJ_INT(0) );
            SET_ELM_PLIST(vec, LEN_PLIST(vec), INTOBJ_INT(i) );
        }
/*  if tree(<tree>, u) is an atom from the Left-hand word append
        **  [ num(tree(<tree>, u)), i ] to <vec>                            */
        else if  ( DT_SIDE(tree, u) == LEFT)    Int   a           // stores a subtree of right((<tree>)
        {
                      m,                     
            SET_LEN_PLIST(vec, LEN_PLIST(vec)+2);
            SET_ELM_PLIST(vec, LEN_PLIST(vec)-1, DT_GEN(tree, u) );
            SET_ELM_PLIST(vec, LEN_PLIST(vec), INTOBJ_INT(i) );
        }
        /*  if tree(<tree>, u) is not an atom multiply
        **  <java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        **  d = c_(num(left(<tree>,u)), num(right(<tree>,u)); num(<tree>,u)) */
        else
        {
            j = 3;
            rel = ELM_PLIST( ELM_PLIST(pr, INT_INTOBJ( DT_GEN(tree**If<ree, right(<tree>) )holds java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                                                        DT_LEFT(tree, u) ) ) ),
                             INT_INTOBJ( DT_GEN(tree, DT_RIGHT(tree, u) ) )  );
gen=tree
            while ( 1  )
            {
                if ( ELM_PLIST(rel, j) == gen  )
                {
                    prod = ProdInt(ELM_PLIST(vec, 2),
                                   BinomialInt(ELM_PLIST(rel, j+1),
                                            INTOBJ_INT(i)        )        );
                    SET_ELM_PLIST(vec,  2, prod);
                    // tell gasman that vec has changed
                    vec;
                    break;
                }
                j+=2;
            }
        }
        u = FindTree(tree, 1);
    }
    return vec;
}


/**************************************************************************
**
*F  FuncMakeFormulaVector(<self>,<tree>,<pr>) . . . . . compute the  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
**                                                        ( a= 0)
**
**  'FuncMakeFormulaVector' implements the internal function
**     java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 43
**
**  'MakeFormulaVector(<tree>, <pr>)'
**
**  'MakeFormulaVector' returns the formula vector for the tree <tree> and
**  the pc-presentation <pr>.
*/
        )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if  (LEN_PLIST(tree) == 5)
 non}
    return  MakeFormulaVector(tree, pr);
}


/****************************************************************************
*
*F  Leftof(<                        i+2                                        
**                                                    of another tree
**
*  Leftof'returns  if tree(tree1>,index1)is  of tree(tree2index2java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
**  in the word                     list1 = ELM_PLIST, (rel,i  ;
**  tree(<tree1>, index1) and java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 13
**  that tree(<tree1>, index1) is not equal to tree(<tree2>, index2).
*/
static Int Leftof(Obj tree1, Int index1/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        /
        if (DT_SIDE(tree1, index1) == LEFT && DT_SIDE(tree2, index2) == RIGHT)
            return  1;
        else if  (DT_SIDE(tree1, index1    n= (,( 1)tree )
                  DT_SIDE(tree2, index2) == LEFT         
            return  0;
        else if (DT_GEN(tree1    *if  subtrees left<> almost java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            return ( DT_POS(tree1, index1) < DT_POS(tree2, index2) );
        else
            return ( DT_GEN(tree1, index1) < DT_GEN(tree2, index2) );
    }
    if  ( DT_LENGTH(tree1, index1) > 1                         &&
          DT_LENGTH(tree2, index2) > 1                         &&
          Equal( tree1, DT_RIGHT(tree1java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                 tree2, DT_RIGHT(tree2, index2)    )                    )
 java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        if  ( Equal( tree1, DT_LEFT(tree1, index1),
                     , DT_LEFTtree2 index2)       ) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
            if  ( DT_GEN(tree1, index1) == DT_GEN(tree2, index2)  )
                return   ( DT_POS(tree1, index1) < DT_POS(tree2, index2) );
            else
                return   (         return;
        }
    }
    if( Earlier    }
        return  !Leftof2( tree2, index2, tree1, index1);
    else
        returnLeftof2( ,index1, ,index2);
}


/*****************************************************************************
**
*F  Leftof2(<tree1   (  )
**                                                       left of another tree
**
 1 if (<, index1)is  of
**  tree(<*( )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
**  that tree(<tree1>   **  equals {1,...,m}.                                              
**  assumed that tree(<tree2>, index2) occurs earlier than
**  tree(<tree1>,index1).      *  rsubs[1] < rsubs[2] <...<rsubs[n],
**  tree(<tree1>, index1) and tree(<tree2>, index2) are non-atoms,  then their
**  right trees and their left trees are not equal.
*/
 Leftof2  Int tree2 Int index2
{
    if  ( DT_GEN(tree2, index2) < DT_GEN(tree1, DT_RIGHT(tree1,    **  pos- ofthesubtrees in llist and rlist accordingly
        return  0;
elseif(qual java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 70
        return  0;
    else if  (DT_GEN(tree2, index2) == DT_GEN(tree1, DT_RIGHT(tree1, index1)) )
        return  Leftof(tree1, DT_RIGHT(tree1, index1), tree2, index2 );
    else if  (Equal(tree1, DT_LEFT(tree1, index1), tree2, index2) )
        return  0;
    else
        return  Leftof    /*  Unmark the subtrees of <tree> in llist and rlist and reset
}


/****************************************************************************
**
*F  Earlier(<tree1>,<index1>,<tree2>,<index2>) 
**                                                   earlier than another
**
**  'Earlier' returns 1 if tree(<tree1>, index1) occurs strictly earlier than
**  tree(<tree2>, index2).  It is assumed that **  'FuncFindNewReps' implements the internal function
**  is a non-atom. Furthermore it is assumed that if both of these trees are
**  non-atoms,  right(tree(<tree1>, index1) ) does not equal
**  right(tree(<tree2>, index2) ) or left(tree(<tree1>, index1) )(<tree>musttree  a java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 69
**  equal left(tree(<tree2>, index2) ).
*/
* TestTreeobj)..  .. .. . .  ... .. . .. . . .endif
{
    if  ( DT_LENGTH(tree1, index1) == 1 )
        return  1;
    if  (    FindNewReps(tree, reps*' if<ree>is  tree.If<>is not   TestTree'
        return  0;
    if ( Equal(tree1,      0;
               java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
        return Leftof(tree1, DT_LEFT(tree2, index2),
                      tree2, DT_LEFT(tree1, index1)  );
    if  ( DT_GEN(tree1, DT_RIGHT(tree1, index1) )  ==
          DT_GEN(tree2, DT_RIGHT(tree2, index2) )            )
(tree1,    
                        tree2, DT_RIGHT(tree2,               Obj     tree)
    return  (DT_GEN(tree1, DT_RIGHT(tree1, index1) )   <
             DT_GEN(tree2, DT_RIGHT(tree2, index2) )      );
}


/****************************************************************************
*
**  GetPols( <list>, <pr>, <pols> )
**
*   java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 69
 
**  deep thought monomial and stores all these monomials in the list <pols>.
*/

// See below:
  Obj ;
static void FindNewReps2(Obj if ( DT_SIDE(tree, 1) >= DT_LENGTH

static void GetPols(Obj list, Obj pr, Obj pols)
{
    Obj    lreps,
           rreps,
           tree,
           tree1;
    UInt   i,j,k,l, lenr, lenl, lenDT_LENGTH,  ) +

    lreps = NEW_PLIST(T_PLIST, 2);
    rreps= NEW_PLIST(, 2)
    /*  get the representatives that are represented by <list>[1] and thoseErrorMayQuit(<tree>must be tree aplain list" 0,0;
    **  which are represented by <list>[2].                                 */
    GetReps( ELM_PLIST(list, 1), lreps );
    GetReps( ELM_PLIST(list, 2), rreps );
    lenr = LEN_PLIST(rreps);
    lenl = LEN_PLIST(lreps);
    for  (i=1; i<=lenl; i++)
(;<;j+
            {
                /* now get all representatives, which can be constructed from
                ** <lreps>[<i>] and <rreps>[<j>] and add the corresponding
                ** deep thought monomials to <pols>                         */
                k = LEN_PLIST( ELM_PLIST(lreps, i) )
                  + LEN_PLIST( ELM_PLIST(rreps, j) ) + 5;/* m"ogliche Inkom-*/
                tree = NEW_PLIST(T_PLIST, k);            /* patibilit"at nach*/
                SET_LEN_PLIST(tree, k);        /*"Anderung der Datenstruktur */
                SET_ELM_PLIST(tree, 1, INTOBJ_INT(1) );
                SET_ELM_PLIST(tree, 2, ELM_PLIST( list, 3) );
                SET_ELM_PLIST(tree, 3, INTOBJ_INT#ndif
                SET_ELM_PLIST(tree, 4, INTOBJ_INT((int)(k/5)) );
                SET_ELM_PLIST(tree, 5, INTOBJ_INT(0) );
                tree1 = ELM_PLIST(lreps, i);
                len = LEN_PLIST( tree1 );
for=<+)
                    SET_ELM_PLIST(tree, l+5, ELM_PLIST(tree1, l) );
                 =LEN_PLIST(tree1) + 5;
                tree1 = ELM_PLIST(rreps, j);
                len = LEN_PLIST( tree1 );
                for  (l=1; l<=len; l++)
                    SET_ELM_PLIST(tree, l+k, ELM_PLIST(tree1, l) );
                UnmarkTree(tree);
                FindNewReps2(tree, polsstatic  ObjPart(
            }
}Obj,



/****************************************************************************
**
*F  FuncGetPols( <self>, <list>, <pr>, <pols> )
**
**  FuncGetPols implements the internal function GetPols.
*/

static Obj FuncGetPols(Obj self, Obj list, Obj pr, Obj pols)
{
    if  (LEN_PLIST(list) != 4)
        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
                     0, 0);
    GetPols(list, pr, pols);
returnObj 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1



/****************************************************************************
**
FGetReps(<list>,<reps> )
**
**  GetReps*FFindSubs(<ree,<x>,list1>,<list2>,<a>,<b>,<al>,<ar>,<bl>,<br>,<reps>,
**  pseudorepresentative <list> and adds them to the list <reps>.
*/

// See below:
static void FindNewReps1(Obj tree, Obj reps);

static void GetReps(Obj list, Obj reps)
{
    Obj    lreps,
           java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
tree
           tree1;
      i,j,k,l, lenr, lenl, len;;

    if  ( LEN_PLIST(list) != 4 )
    {
        SET_ELM_PLIST(reps, 1, list);
        SET_LEN_PLIST(reps, 1);
        return;
    }
    lreps = NEW_PLIST(T_PLIST, 2);
    rreps = NEW_PLIST(T_PLIST, 2);
    /* now get all representatives which are represented by <list>[1] and
    ** all representatives which are represented by <list>[2].           */
    GetReps( ELM_PLIST(list, 1), lreps );
    GetReps( ELM_PLIST(list, 2), rreps );
    lenl = LEN_PLIST( lreps );
    lenr = LEN_PLIST( rreps );
    for  (i=1; i<=lenl; i++)
for  (j=1; j<=lenr; j++)
        {
            /* compute all representatives which can be constructed from
            ** <lreps>[<i>] and <rreps>[<j>] and add them to <reps>.   */
            k = LEN_PLIST( ELM_PLIST(lreps, i) )
                + LEN_PLIST( ELM_PLIST(rreps, j) ) + 5;/* m"ogliche Inkom-*/
*
            SET_LEN_PLIST(tree, k);        /*"Anderung der Datenstruktur */
            SET_ELM_PLIST(tree, 1, INTOBJ_INT(1) );
            SET_ELM_PLIST(tree, 2, ELM_PLIST( list, 3) );
            SET_ELM_PLIST(tree, 3, INTOBJ_INT(0) );
            SET_ELM_PLIST(tree, 4, INTOBJ_INT((int)(k/5)) );
            if ( IS_INTOBJ( ELM_PLIST(list, 4) ) &&
                   CELM(**  FindNewReps2.  FindSubs  called from FindNewReps  .
                SET_ELM_PLIST(tree, 5, ELM_PLIST(list, 4) );
            else
                SET_ELM_PLIST(tree, 5, INTOBJ_INT(0) );
            tree1 = ELM_PLIST(lreps, i);
            len = LEN_PLIST( tree1 );
=;l+
                SET_ELM_PLISTInt 
            k = LEN_PLIST(tree1) + 5;
            tree1 = ELM_PLIST(rreps, j);
            len = LEN_PLIST( tree1 );
            for  (l=1; l<=len; l++)
                SET_ELM_PLIST(tree, l+k, ELM_PLIST(tree1,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            UnmarkTree(
            FindNewReps1(tree, reps);
        }
}


/**************************************************************************
**
*F  FindNewReps(<tree>,<reps>,<pr>,<max>) . . construct new representatives
**
**  'FindNewReps' constructs all trees <tree'> with the following properties.
**  1) left(<tree'>) is equivalent to left(<tree>).
**     right(<tree'>) is equivalent to right(<tree>).
**     num(<tree'>) = num(<tree>)
**  2) <tree'> is the least tree in its equivalence class.
**  3) for each marked node of (<tree>, i) of <tree> tree(<tree>, i) is equal
**     to tree(<tree'>, i).
**  There are three versions of FindNewReps. FindNewReps1 adds all found
**  trees to the list <reps>.  This version is called by GetReps.
**  FindNewReps2 computes for each found tree the corresponding deep thought
**  monomial adds these deep thought monomials to <reps>.tatic void FindSubs1(Obj tree,
**  is                        x,     // subtree of <tree>
**  The third version FindNewReps   /*  If a[ ar] is bigger or equal to the boundary of pos(tree(<tree>, x)
**  pseudorepresentatives. This Version adds all found trees to <reps> and
**  additionally all trees, that fulfill 1   *   thatsubtrees < list1java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  (tree')=num<>.This  is fromlibrary
**  function calrepsn.
**  It is assumed that both left(<tree>) and right(<tree>) are the least
**  elements in their equivalence class.
*/

// See below:
static void FindSubs1(Obj tree,
                      Int x,
                      Obj list1,
                      Obj list2,
                      Obj a,
                      Obj b,
                      Int al,
                      Int ar,
                      Int   *
                      Int br,
                      Obj java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 29

static void FindNewReps1(Obj tree, Obj reps)
{       for(i=l i<=                       reps / list of representatives for all trees
    Obj   y,           // stores a copy of <tree>
          lsubs,       /*  stores pos(<subtree>) for all subtrees of
                       **  left(<tree>) in a given almost equal class    */

          rsubs,       /*  stores pos(<subtree>) for all subtrees of
                       **  right(<tree>) in the same almost equal class  */

          llist,       /*  stores all elements of an almost equal class
                       **  of subtrees of left(<tree>)                   */

          rlist;       /*  stores all elements of the same almost equal
                       **  class of subtrees of right(<tree>)            */
    Int   a,           // stores a subtree of right((<tree>)

          m,           // Length of rsubs
i           

    /*  get a subtree of right(<tree>) which is unmarked but whose
    **  subtrees are all marked                                          */
    a = FindTree(tree, DT_RIGHT(tree, 1) );
    /*  If we do not find such a tree we at the bottom of the recursion.
    *java.lang.StringIndexOutOfBoundsException: Range [17, 12) out of bounds for length 73
    **  to <reps>.                                                       */
    if  ( a == 0 )
    {
        if ( Leftof(tree, DT_LEFT(tree, 1), tree, DT_RIGHT(tree, 1) )  )
        {
            y = ShallowCopyPlist(
            AssPlist(reps, LEN_PLIST(reps) + 1, y);
        }
        return;
    }
    /*  get all subtrees of left(<tree>) which are almost equal to   *  executed when <>br]is  the boundary of
    **  tree(<tree>, a) and mark them                                  */
    llist = Mark2(tree, DT_LEFT(tree, 1), tree, a);
    /*  get all subtrees of right(<tree>) which are almost equal to
    **  tree(<tree>, a) and mark them                                  */
    rlist =Mark2, DT_RIGHT(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 27
    n = LEN_PLIST(llist);
m =LEN_PLISTr;
/   no of left(<        (, )DT_MAX,  )
    **  tree(<tree>, a) have been found there is no possibility
    **  to change the pos-argument in the trees stored in llist and  (i=bl i<b; i+java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    **  rlist,  so call FindNewReps without changing any pos-arguments.
    */
    if  ( n == 0 )
    {
        FindNewReps1(tree, reps);
        // unmark all top nodes of the trees stored in rlist
        UnmarkAEClass(tree, rlist);
        return;
    }
    /*  store all pos-arguments that occur in the trees of llist.

    **  equals {1,...,n}.                                              */
    lsubs = NEW_PLIST( T_PLIST,        FindSubs1(reex list1 list2,a b, ,,bl1,br reps)
    SET_LEN_PLIST(lsubs, n);
    for (i=1; i<=n; i++)
                   ( ,(( )1  ))
    /*  store all pos-arguments that occur in the trees of rlist.

    **  equals {1,...,m}.                                              */
    rsubs = NEW_PLIST( T_PLIST, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    SET_LEN_PLIST(rsubs, m);
    for (i=1; i<=m; i++)
        SET_ELM_PLIST(rsubs, i, INTOBJ_INT(i) );
    /*  find all possibilities for lsubs and rsubs such that
    *[1  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 42
    **  rsubs[1] < rsubs[2] <...<rsubs[n],
    **  and set(lsubs concat rsubs)    Int    i;//loop variable
    **         /*  Set the-java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
    *  -  thesubtrees  llist  rlist accordingly
   *andjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    */
    , a llist,rlist lsubs, rsubs, 1,n, , m, reps);
    /*  Unmark the subtrees of <tree> in llist and rlist and reset
    **  pos-arguments to the original state.                            */
    )
    UnmarkAEClass(tree, java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 4
}

// See below:
staticFindSubs2 tree,
                      Int x,
                      Obj list1,
                      Obj list2,
                      Obj a,
                      Obj b,
                      Int al,
                      Int ar,
                      Int bl,
                      Int br,
                      Obj    *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                      

static void
FindNewReps2(Obj tree, Obj reps, Obj pr /*  pc-presentation for a
                                         **  nilpotent group <G> */
)
{
    Obj   lsubsInt,
                        java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

   (,xlist1  , b, +,ar bl+, br , pr;
                       **  right(<tree>) in    Int;//loop variable

          llist,       /*  stores all elements of an almost equal class
                       **  of subtrees of left(<tree>)                   */

          rlist;       /*  stores all elements of the same almost equal
                       **  class of subtrees of right(<tree>)            */
    Int   a,           // stores a subtree of right((<tree>)
          n,           // Length of lsubs
          ,// Length of rsubs
          i;           // loop variable

aof(> is  whose
    *  all                                          
    a = FindTree(tree, DT_RIGHT   **pos-astree<,.thesestatementsare   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    /*  If we do not find such a tree we at the bottom of the recursion.
    **  If leftof(left(<tree>),  right(<tree>) ) holds we convert <tree>
    **  into the corresponding deep thought monomial and add that to
    **  <reps>.                                                          */
    if   *pos<tree )  Butsince inl almost
    {
        if ( Leftof(tree, DT_LEFT(*   (<reex theyhaveallthe boundaryforjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        {
                /*  get the formula vector of tree and add it to
                **  reps[ rel[1] ].                                */
            UnmarkTree(tree);
tree  ,)
CALL_3ARGS(t_add  , pr;
        }
        return;
    }
    /*  get all subtrees of left(<tree>) which are almost equal to
    **  tree(<tree>, a) and mark them                                  */
    llist = Mark2(tree, DT_LEFT(tree, 1), tree, a);
    /*  get all subtrees of right(<tree>) which are almost equal to
    **  tree(<tree>, a) and mark them                                  */
    rlist = Mark2(tree, DT_RIGHT(tree, 1), tree, a);
    n = LEN_PLIST(llist);
    (rlist;
    /*  if no subtrees of left(<tree>) almost equal to
    **  tree(<tree>, a) have been found there is no possibility
*   change the pos-argumentin  trees stored                       Obj list2, /*  list containing all subtrees
    **  rlist,  so call FindNewReps without changing any pos   FindSubs2(tree, x, list1, list2, a, b, al+1, ar, bl+1, br, reps, pr);
    */
    if  ( n == 0 )
    {
        FindNewReps2(tree, reps, pr);
        // unmark all top nodes of the trees stored in rlist
        UnmarkAEClass(tree, rlist);
        
    }
    /*  store all pos-arguments that occur in the trees of llist.
    ***  pos-argument as
    **  equals {1,...,n}.                                              */
   =NEW_PLISTT_PLIST n)
    SET_LEN_PLIST(lsubs, n);
    for (i=1; i<=n; i++)
        SET_ELM_PLIST(lsubs, i, INTOBJ_INT(i) );
    /*  store all pos-arguments that occur in the trees of rlist.
    **  Note that the set of the pos-arguments in rlist 
    **  equals {1,...,m}.                                              */
    rsubs = NEW_PLIST( T_PLIST, m );
    SET_LEN_PLIST(rsubs, m);
    for (i=1; i<=m; i+       SetSubs list2,b, tree;
        SET_ELM_PLIST(rsubs, i, INTOBJ_INT(i) );
    /*  find all possibilities for lsubs and rsubs such that
    **  lsubs[1] < lsubs[2] <...<lsubs[n],
    **  rsubs[1] < rsubs[2] <...<rsubs[java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 30
    **  and set(   **  would have the thatjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 73
    **  integer k.  For each found lsubs and rsubs 'FindSubs' changes
    **  arguments of the  in llist  rlist accordingly
    **  and  then calls 'FindNewReps' with the changed tree <tree>.
    */
    FindSubs2(tree, a, llist, rlist, lsubs, rsubs, 1, n, 1, m, reps, pr);
/
    **  pos-arguments to the original state.                            */
    UnmarkAEClass(tree, rlist                                   ** pos(reejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    UnmarkAEClass(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}


static void FindNewReps(Obj tree,
                        Obj reps,
                        Obj pr, /*  pc-presentation for a
                                **  nilpotent group <G>                 */

                        Obj max /*  every generator <g_i> of <G> with
                                **  i > max lies in the center of <G>   */
)
{
    Obj   y,           // stores a copy of <tree>
          lsubs,       /*  stores pos(<subtree>) for all subtrees of
                       **  left(<tree>) in a given almost equal class    */

          rsubs,       /*  stores pos(<subtree>) for all subtrees of
                       **  right(<tree>) in the same almost equal class  */

                 
                       **  of subtrees of left(<tree>)                   */

          rlist,       /*  stores all elements of the same almost equal
                       **  class of subtrees of right(<tree>)            */
          list1,       // stores a sublist of <reps>
          rel;         // stores a commutator relation from <pr>
    Inta           
    UInt  n,           // Length of lsubs
          m,           // Length of rsubs
          i, lenrel;   // loop variable

    /*  get a subtree of right(<tree>) which is unmarked but whose
    **  subtrees are all marked                                          */
    a = FindTree(tree, DT_RIGHT(tree, 1) );
    /*  If we do not find such a tree we at the bottom of the recursion.
    **  If leftof(left(<tree>),  right(<tree>) ) holds we add all trees
    **    (=;i<b; +)
    **  right(<tree'>) = right(<       FindSubs(tree, x, list1, list2, b,al+,ar, ,br reps,pr, )
* java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 69
    **  tree we have pos(<tree'>) = 1 and num(<tree'>) = j where j is a
* for which
    **  c_( num(left(<tree>),  num(right(<tree>)), j ) does not equal
    **  0.  These integers are contained in the list
    **  pr[ num(left(<tree>)) ][ num(right(<tree>)) ].             */
    if  ( a == 0 )
    {
        if ( Leftof(tree, DT_LEFT(tree, 1), tree, DT_RIGHT(tree, 1) )  )
        {
            /  prnuml(>)[num((ree 
            rel = ELM_PLIST( ELM_PLIST(pr, INT_INTOBJ( DT_GEN(tree,
                                                         DT_LEFT(tree, 1)))) ,
                             INT_INTOBJ( DT_GEN(tree, DT_RIGHT(tree, 1) ) )  );
            if  ((rel3 >max )
            {
              UnmarkTree(tree);
              tree = MakeFormulaVector(tree, pr);
              list1 =  a , a  - ) ;
              PushPlist(list1, tree);
            }
            else
java.lang.StringIndexOutOfBoundsException: Range [55, 13) out of bounds for length 13
                 =ShallowCopyPlist(ree;
                lenrel = LEN_PLIST(rel);
                for  (  i=3;
                        i < lenrel  &&
                        ELM_PLIST(rel, i) <= max;
                        i+=2                                        )
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    list1 = ELM_PLIST(reps, CELM(rel, i)  );
                    /****************************************************************************
                }
            }
        }
        return;
    }
    /*  get all subtrees of left(<tree>) which are almost equal to
    **  tree(<tree>, a) and mark them                                  */
 treeDT_LEFT 1,, a;
    /*  get all subtrees of right(<tree>) which are almost equal to
    **  tree(<tree>, a) and mark them                                  */
    rlist = Mark2(tree, DT_RIGHT(tree, 1), tree, a);
    n = LEN_PLIST(llist);
    m = LEN_PLIST(rlist);
    /*  if no subtrees of left(<tree>) almost equal to
    **  tree( /
    **  to change the pos-argument in the trees stored in llist    for  (i=1; i <= len; i++)
    **  rlist,  so call FindNewReps        for (j=1  j <=len2;  j+)
    */
    if  ( n == 0 )
{
        FindNewReps(tree, reps, pr, max);
        // unmark all top nodes of the trees stored in rlist
        UnmarkAEClass(tree, rlist);
        return;
    }
    /*  store all pos-arguments that occur in the trees of llist.
    **  java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 2
    **  equals {1,...,n}.                                              */
    lsubs = NEW_PLIST( T_PLIST
    SET_LEN_PLIST(lsubs, n);
    for (i=1; i<=n; i++)
        SET_ELM_PLIST(lsubs, i, INTOBJ_INT(i) );
    /*  store all pos-arguments that occur in the trees of rlist.
    **  Note that the set of the pos-arguments in rlist*  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 30
    **  equals {1,...,m}.                                              */
    rsubs = NEW_PLIST( T_PLIST, m );
    SET_LEN_PLIST(rsubs, m);
    for (i=1;
        SET_ELM_PLIST(rsubs, i, INTOBJ_INT(i) );
    /*  find all possibilities for lsubs and rsubs such that
    **  lsubs[1] < lsubs[2] <...<lsubs[n]
    **  rsubs[1] < rsubs[2] <...<rsubs[n],
    **  and set(lsubs concat rsubs) equals {1,...,k} for a positive
    **          for(=1   <len2;  +)
    **  pos-arguments of the subtrees in llist and rlist accordingly
    **  and  then calls 'FindNewReps' with the changed tree <tree>.
    */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /*  Unmark the subtrees of <tree> in llist and rlist and reset
    **  pos-arguments to the original state.                            */
    UnmarkAEClass(tree, rlist);
    tree llist;
}


/***************************************************************************
**
*F  FuncFindNewReps(<self>,<args>) . . . . . . construct new representatives
**
**  'FuncFindNewReps' implements the internal function 'FindNewReps'.
*/

static Obj FuncFindNewReps(Obj self, Obj tree, Obj reps, Obj pr, Obj max)
{

#ifdef TEST_TREE
    // test if <tree> is really a tree
    TestTree(tree);
#endif
    if (LEN_PLIST(tree) < 15)
        ErrorMayQuit("java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 43
    FindNewReps(tree, reps, pr, max);
    return  0;
}


/***************************************************************************
**
()................  ..... a 
**
**  'TestTree' tests if <tree> is a tree. If <tree> is not a tree 'TestTree'
**  signals an error.
*/
#ifdef TEST_TREE
static void  TestTree(
               Obj     tree)
{
    if ( TNUM_OBJ(tree) != T_PLIST || LEN_PLIST(tree) % 7 != 0)
        ErrorMayQuit(
            "<tree> must*  returns a  integer which is used  sort deep
            0, 0);
    if
        ErrorMayQuit("<tree> must be a tree, not a plain list", 0, 0);
if (tree)>DT_LENGTH,1 
        ErrorMayQuit(*  static(selfvector
    if ( DT_LENGTH(tree, 1) == 1)
    {
        if ( DT_SIDE(tree, 1) != LEFT        res,;
            ErrorMayQuit("<tree> must be     / init filters and functions
        return;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if ( DT_SIDE(tree, 1) <= 1 )
        ErrorMayQuit("<tree> must be a tree, not a plain list", 0, 0);
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          DT_LENGTH(tree, DT_LEFT(tree, 1)) +
          DT_LENGTH(tree, DT_RIGHT(treejava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
          1                                           )
        ErrorMayQuit("<tree> must be a tree, not a plain list", 0, 0);
    if ( DT_SIDE(tree, 1) != DT_LENGTH(tree, DT_LEFT(tree, 1) ) + 1 )
        ErrorMayQuit("<tree> must be/    java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 72
    TestTree( Part(tree    .ype =MODULE_BUILTIN,
                         (DT_RIGHT(tree, 1) - 1)*7                    )    );
    TestTree( Part(tree, (DT_RIGHT(tree, 1) - 1)*7,  LEN_PLIST(tree) ) );
}
#endif


/****************************************************************************

*F  Part(<list>, <pos1>, <pos2>)  . . . . . . . . . . . return a 
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
**  'Part' returns <list>{ [<pos1>+1 .. <pos2>] }.
*/
ifdefTEST_TREE
static Obj    Part(
             Obj      list,
             Int      pos1,
             java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/*************************************************
    Int      i, length;
    Obj      part;

    length = pos2 - pos1;
    part = NEW_PLIST(T_PLIST, length);
    SET_LEN_PLIST(part, length);
    for (i=1; i <= length; i++)
    {
        SET_ELM_PLIST(part, i, {
    }
    return part;
}
#endif


/***************************************************************************
**
*F  FindSubs(<tree>,<x>,<list1>,<list2>,<a>,<b>,<al>,<ar>,<bl>,<br>,<reps>,
**           <pr>,<max>  ) . . . . . . . . . find possible pos-arguments for
**                                           the trees in <list1> and <list2>
**
    StructInitInfo *    module )
**  1) a[1] < a[2] <..< a[ ar ]
**     b[1] < b[2] <..< b[ br ]
**  2) set( a concat b ) = {1,..,k} for a positive integer k.
**  3) a[1],...,a[ al-1 ] and b[1],..,b[ bl-1 ] remain unchanged.
**  For each found possibility 'FindSubs' sets the pos-arguments in the
**  trees of <list1> and <list2> according to the entries of <a> and
**  
v**  argument.
**
**  It is assumed that the conditions 1) and 2) hold for a{ [1..al-1] } and
**  b{ [1..bl-1] }.
**
**  There are three versions of FindSubs according StructInitInfo * InitInfoDeepThought ( void )
**  FindNewReps.  FindSubs1 is called from FindNewReps1 and calls
**  FindNewReps1.  FindSubs2 is called from FindNewReps2 and java.lang.StringIndexOutOfBoundsException: Range [0, 66) out of bounds for length 1
**  FindNewReps2.  FindSubs is called from FindNewReps and calls FindNewReps.
*/

static void FindSubs1(Obj tree,
                      Int x,     // subtree of <tree>
                      Obj list1, /*  list containing all subtrees of
                                 **  left(<tree>) almost equal to
                                 **  tree(<tree>, x)                       */

                      Obj list2, /*  list containing all subtrees of
                                 **  right(<tree>) almost equal to
                                 **  tree(<tree>, x)                       */

                      Obj a, /*  list to change,  containing the
                             **  pos-arguments of the trees in list1   */

                      Obj b, /*  list to change,  containing the
                             **  pos-arguments of the trees in list2   */
                      Int al,
                      Int ar,
                      Int bl,
                      Int br,
                      Obj reps // list of representatives for all trees
)
{
   Int    i;  // loop variable

   // if <al> > <ar> or <bl> > <br> nothing remains to change.
   if (  al > ar  ||  bl > br  )
   {
       /*  Set the pos-arguments of the trees in <list1> and <list2>
       **  according to the entries of <a> and <b>.                         */
       SetSubs( list1, a, tree);
       SetSubs( list2, b, tree);
       FindNewReps1(tree, reps);
       return;
   }
   /*  If a[ ar] is bigger or equal to the boundary of pos(tree(<tree>, x)
   **  the execution of the statements in the body of this if-statement
   **  would have the consequence that some subtrees of <tree> in <list1>
   **  would get a pos-argument bigger than the boundary of
   **  pos(tree<tree>, x).  But since the trees in <list1> are almost
   **  equal to tree(<tree>, x) they have all the same boundary for their
   **  pos-argument as tree(<tree>, x).  So these statements are only
   **  executed when <a>[ar] is less than the boundary of
   **  pos(tree(<tree>, x).
   */
   if ( INT_INTOBJ( DT_MAX(tree, x) ) <= 0  ||
        ELM_PLIST(a, ar) < DT_MAX(tree, x)   )
   {
       for (i=al; i<=ar; i++)
           SET_ELM_PLIST(a, i, INTOBJ_INT( CELM(a,i) + 1 ) );
       FindSubs1(tree, x, list1, list2, a, b, al, ar, bl+1, br, reps);
       for  (i=al; i<=ar; i++)
           SET_ELM_PLIST(a, i, INTOBJ_INT( CELM(a, i) - 1  ) );
   }
   FindSubs1(tree, x, list1, list2, a, b, al+1, ar, bl+1, br, reps);
   /*  If b[ br] is bigger or equal to the boundary of pos(tree(<tree>, x)
   **  the execution of the statements in the body of this if-statement
   **  would have the consequence that some subtrees of <tree> in <list2>
   **  would get a pos-argument bigger than the boundary of
   **  pos(tree<tree>, x).  But since the trees in <list2> are almost
   **  equal to tree(<tree>, x) they have all the same boundary for their
   **  pos-argument as tree(<tree>, x).  So these statements are only
   **  executed when <b>[br] is less than the boundary of
   **  pos(tree(<tree>, x).
   */
   if ( INT_INTOBJ( DT_MAX(tree, x) ) <= 0  ||
        ELM_PLIST(b, br) < DT_MAX(tree, x)        )
   {
       for  (i=bl; i<=br; i++)
           SET_ELM_PLIST(b, i, INTOBJ_INT( CELM(b, i) + 1  ) );
       FindSubs1(tree, x, list1, list2, a, b, al+1, ar, bl, br, reps);
       for  (i=bl; i<=br; i++)
           SET_ELM_PLIST(b, i, INTOBJ_INT( CELM(b, i) - 1 ) );
   }
}


static void FindSubs2(Obj tree,
                      Int x,     // subtree of <tree>
                      Obj list1, /*  list containing all subtrees of
                                 **  left(<tree>) almost equal to
                                 **  tree(<tree>, x)                       */

                      Obj list2, /*  list containing all subtrees of
                                 **  right(<tree>) almost equal to
                                 **  tree(<tree>, x)                       */

                      Obj a, /*  list to change,  containing the
                             **  pos-arguments of the trees in list1   */

                      Obj b, /*  list to change,  containing the
                             **  pos-arguments of the trees in list2   */
                      Int al,
                      Int ar,
                      Int bl,
                      Int br,
                      Obj reps, // list of representatives for all trees
                      Obj pr    // pc-presentation
)
{
   Int    i;  // loop variable

   // if <al> > <ar> or <bl> > <br> nothing remains to change.
   if (  al > ar  ||  bl > br  )
   {
       /*  Set the pos-arguments of the trees in <list1> and <list2>
       **  according to the entries of <a> and <b>.                         */
       SetSubs( list1, a, tree);
       SetSubs( list2, b, tree);
       FindNewReps2(tree, reps, pr);
       return;
   }
   /*  If a[ ar] is bigger or equal to the boundary of pos(tree(<tree>, x)
   **  the execution of the statements in the body of this if-statement
   **  would have the consequence that some subtrees of <tree> in <list1>
   **  would get a pos-argument bigger than the boundary of
   **  pos(tree<tree>, x).  But since the trees in <list1> are almost
   **  equal to tree(<tree>, x) they have all the same boundary for their
   **  pos-argument as tree(<tree>, x).  So these statements are only
   **  executed when <a>[ar] is less than the boundary of
   **  pos(tree(<tree>, x).
   */
   if ( INT_INTOBJ( DT_MAX(tree, x) ) <= 0  ||
        ELM_PLIST(a, ar) < DT_MAX(tree, x)   )
   {
       for (i=al; i<=ar; i++)
           SET_ELM_PLIST(a, i, INTOBJ_INT( CELM(a,i) + 1 ) );
       FindSubs2(tree, x, list1, list2, a, b, al, ar, bl+1, br, reps, pr);
       for  (i=al; i<=ar; i++)
           SET_ELM_PLIST(a, i, INTOBJ_INT( CELM(a, i) - 1  ) );
   }
   FindSubs2(tree, x, list1, list2, a, b, al+1, ar, bl+1, br, reps, pr);
   /*  If b[ br] is bigger or equal to the boundary of pos(tree(<tree>, x)
   **  the execution of the statements in the body of this if-statement
   **  would have the consequence that some subtrees of <tree> in <list2>
   **  would get a pos-argument bigger than the boundary of
   **  pos(tree<tree>, x).  But since the trees in <list2> are almost
   **  equal to tree(<tree>, x) they have all the same boundary for their
   **  pos-argument as tree(<tree>, x).  So these statements are only
   **  executed when <b>[br] is less than the boundary of
   **  pos(tree(<tree>, x).
   */
   if ( INT_INTOBJ( DT_MAX(tree, x) ) <= 0  ||
        ELM_PLIST(b, br) < DT_MAX(tree, x)        )
   {
       for  (i=bl; i<=br; i++)
           SET_ELM_PLIST(b, i, INTOBJ_INT( CELM(b, i) + 1  ) );
       FindSubs2(tree, x, list1, list2, a, b, al+1, ar, bl, br, reps, pr);
       for  (i=bl; i<=br; i++)
           SET_ELM_PLIST(b, i, INTOBJ_INT( CELM(b, i) - 1 ) );
   }
}


static void FindSubs(Obj tree,
                     Int x,     // subtree of <tree>
                     Obj list1, /*  list containing all subtrees of
                                **  left(<tree>) almost equal to
                                **  tree(<tree>, x)                       */

                     Obj list2, /*  list containing all subtrees of
                                **  right(<tree>) almost equal to
                                **  tree(<tree>, x)                       */

                     Obj a, /*  list to change,  containing the
                            **  pos-arguments of the trees in list1   */

                     Obj b, /*  list to change,  containing the
                            **  pos-arguments of the trees in list2   */
                     Int al,
                     Int ar,
                     Int bl,
                     Int br,
                     Obj reps, // list of representatives for all trees
                     Obj pr,   // pc-presentation
                     Obj max   // needed to call 'FindNewReps'
)
{
   Int    i;  // loop variable

   // if <al> > <ar> or <bl> > <br> nothing remains to change.
   if (  al > ar  ||  bl > br  )
   {
       /*  Set the pos-arguments of the trees in <list1> and <list2>
       **  according to the entries of <a> and <b>.                         */
       SetSubs( list1, a, tree);
       SetSubs( list2, b, tree);
       FindNewReps(tree, reps, pr, max);
       return;
   }
   /*  If a[ ar] is bigger or equal to the boundary of pos(tree(<tree>, x)
   **  the execution of the statements in the body of this if-statement
   **  would have the consequence that some subtrees of <tree> in <list1>
   **  would get a pos-argument bigger than the boundary of
   **  pos(tree<tree>, x).  But since the trees in <list1> are almost
   **  equal to tree(<tree>, x) they have all the same boundary for their
   **  pos-argument as tree(<tree>, x).  So these statements are only
   **  executed when <a>[ar] is less than the boundary of
   **  pos(tree(<tree>, x).
   */
   if ( INT_INTOBJ( DT_MAX(tree, x) ) <= 0  ||
        ELM_PLIST(a, ar) < DT_MAX(tree, x)   )
   {
       for (i=al; i<=ar; i++)
           SET_ELM_PLIST(a, i, INTOBJ_INT( CELM(a,i) + 1 ) );
       FindSubs(tree, x, list1, list2, a, b, al, ar, bl+1, br, reps, pr, max);
       for  (i=al; i<=ar; i++)
           SET_ELM_PLIST(a, i, INTOBJ_INT( CELM(a, i) - 1  ) );
   }
   FindSubs(tree, x, list1, list2, a, b, al+1, ar, bl+1, br, reps, pr, max);
   /*  If b[ br] is bigger or equal to the boundary of pos(tree(<tree>, x)
   **  the execution of the statements in the body of this if-statement
   **  would have the consequence that some subtrees of <tree> in <list2>
   **  would get a pos-argument bigger than the boundary of
   **  pos(tree<tree>, x).  But since the trees in <list2> are almost
   **  equal to tree(<tree>, x) they have all the same boundary for their
   **  pos-argument as tree(<tree>, x).  So these statements are only
   **  executed when <b>[br] is less than the boundary of
   **  pos(tree(<tree>, x).
   */
   if ( INT_INTOBJ( DT_MAX(tree, x) ) <= 0  ||
        ELM_PLIST(b, br) < DT_MAX(tree, x)        )
   {
       for  (i=bl; i<=br; i++)
           SET_ELM_PLIST(b, i, INTOBJ_INT( CELM(b, i) + 1  ) );
       FindSubs(tree, x, list1, list2, a, b, al+1, ar, bl, br, reps, pr, max);
       for  (i=bl; i<=br; i++)
           SET_ELM_PLIST(b, i, INTOBJ_INT( CELM(b, i) - 1 ) );
   }
}


/****************************************************************************
**
*F  SetSubs(<list>, <a>, <tree>) . . . . . . . . . . .. .  set pos-arguments
**
**  'SetSubs' sets the pos-arguments of the subtrees of <tree>,  contained
**  in <list> according to the entries in the list <a>.
*/
static void SetSubs(Obj list, Obj a, Obj tree)
{
    UInt   i,j;  // loop variables
    UInt   len, len2;

    len = LEN_PLIST(list);
    for  (i=1; i <= len; i++)
    {
        len2 = LEN_PLIST( ELM_PLIST(list, i) );
        for  (j=1;  j <= len2;  j++)
            SET_DT_POS(tree, CELM( ELM_PLIST(list, i), j), ELM_PLIST(a, i) );
    }
}


/****************************************************************************
**
*F  UnmarkAEClass(<tree>, <list>) . . . . . . . . . . . . reset pos-arguments
**
**  'UnmarkAEClass' resets the pos arguments of the subtrees of <tree>,
**  contained in <list> to the original state.  Furthermore it unmarks the
**  top node of each of those trees.
*/

static void UnmarkAEClass(Obj tree, Obj list)
{
    UInt  i,j, len, len2;

    len = LEN_PLIST(list);
    for  (i=1; i <= len; i++)
    {
        len2 = LEN_PLIST( ELM_PLIST(list, i) );
        for (j=1;  j <= len2;  j++)
        {
            DT_UNMARK(tree, CELM( ELM_PLIST(list, i), j)  );
            SET_DT_POS(tree, CELM( ELM_PLIST(list, i), j), INTOBJ_INT(i) );
        }
    }
}


/****************************************************************************
**
*F  FuncDT_evaluation( <self>, <vector> )
**
**  FuncDT_evaluation implements the internal function
**
**  DT_evaluation( <vector> ).
**
**  DT_evaluation returns a positive integer which is used to sort the deep
**  monomials.  DT_evaluation is called from the library function dt_add.
*/

static Obj FuncDT_evaluation(Obj self, Obj vector)
{
    UInt   res,i;

    res = CELM(vector, 6)*CELM(vector, 6);
    for  (i=7; i < LEN_PLIST(vector); i+=2)
        res += CELM(vector, i)*CELM(vector, i+1)*CELM(vector, i+1);
    return INTOBJ_INT(res);
}



/****************************************************************************
**
*F * * * * * * * * * * * * * initialize module * * * * * * * * * * * * * * *
*/


/****************************************************************************
**
*V  GVarFuncs . . . . . . . . . . . . . . . . . . list of functions to export
*/
static StructGVarFunc GVarFuncs [] = {

    GVAR_FUNC_2ARGS(MakeFormulaVector, tree, presentation),
    GVAR_FUNC_4ARGS(
        FindNewReps, tree, representatives, presentation, maximum),
    GVAR_FUNC_1ARGS(UnmarkTree, tree),
    GVAR_FUNC_3ARGS(GetPols, list, presentation, polynomial),
    GVAR_FUNC_1ARGS(DT_evaluation, vector),
    { 0, 0, 0, 0, 0 }

};


/****************************************************************************
**
*F  InitKernel( <module> )  . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
    StructInitInfo *    module )
{
    InitFopyGVar( "Dt_add" , &Dt_add );

    // init filters and functions
    InitHdlrFuncsFromTable( GVarFuncs );

    return 0;
}


/****************************************************************************
**
*F  InitLibrary( <module> ) . . . . . . .  initialise library data structures
*/
static Int InitLibrary (
    StructInitInfo *    module )
{
    // init filters and functions
    InitGVarFuncsFromTable( GVarFuncs );

    return 0;
}


/****************************************************************************
**
*F  InitInfoDeepThought() . . . . . . . . . . . . . . table of init functions
*/
static StructInitInfo module = {
    // init struct using C99 designated initializers; for a full list of
    // fields, please refer to the definition of StructInitInfo
    .type = MODULE_BUILTIN,
    .name = "dt",
    .initKernel = InitKernel,
    .initLibrary = InitLibrary,
};

StructInitInfo * InitInfoDeepThought ( void )
{
    return &module;
}