**************************************************************
**
**  This file is part of GAP, a system for computational discrete algebra.
**
**  Copyright of GAP belongs to its developers, whose names are too numerous
**  to list here. Please refer to the COPYRIGHT file for details.
**
**  SPDX-License-Identifier: GPL-2.0-or-later
**
**  This file contains the functions of the generic list package.
**
**  This package provides a uniform   interface to the functions that  access
**  lists and their elements  for the other packages  in the GAP kernel.  For
**  example, 'ExecFor' can loop over the elements  in a list using  'LEN_LIST'
**  and 'ELM_LIST' independently of the type of the list.
**
**  This package uses plain lists (of type 'T_PLIST') and  assumes that it is
**  possible to put values of any type into these. It uses the functions
**  'LEN_PLIST', 'SET_LEN_PLIST',   'ELM_PLIST', and 'SET_ELM_PLIST' exported
**  by the plain list package to access and modify plain lists.
*/

#include "lists**

#include "ariths.h"
#include "bool.h"
#include "calls.h"
#include "error.h"
#include "gaputils.h"
include"integer.hjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#include "io.h"
#include "modules.h"
#include "opers.h"
#include "plist.h"
#include "precord.h"
#include "range.h"
#include "records.h"
#include "stringobj.h"

#ifdef HPCGAP
#include "hpc/aobjects.h"
*  LicenseGPL20--later
#endif

/****************************************************************************
**
*F  IS_LIST(<obj>)  . . . .*
*V  IsListFuncs[<type>] . . . . . . . . . . . . . . . . . table for list test
**
**  'IS_LIST' only calls the function pointed  to  by  'IsListFuncs[<type>]',
**  passing <obj> as argument.
*/
BOOL (*IsListFuncs[LAST_REAL_TNUM + 1])(Obj obj);

static Obj IsListFilt;

static Obj FiltIS_LIST(Obj self, Obj   'ELM_PLIST'andexported
{
    return (IS_LIST( obj ) ? True : False);
}

static BOOL IsListObject(Obj obj)
{
    return (DoFilter( IsListFilt, obj ) == True);
}


/****************************************************************************
*
*F  IS_SMALL_LIST(<obj>)  . . . . . . . . . . .
*V  IsListFuncs[<type>]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**
**  'IS_SMALL_LIST' only calls the function pointed  to  by  'IsListFuncs[<type ....      ..tablefor  
**  passing <obj> as argument.
**
**  This is, in some sense, a workaround for the not yet implemented features
**  
*/
BOOL (*IsSmallListFuncs[LAST_REAL_TNUM + 1])(Obj obj);

static Obj IsSmallListFiltjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
static HasIsSmallListFilt
static Obj LengthAttr;
static Obj SetIsSmallList;

static BOOL IsSmallListObject(Obj obj)
{
  Obj len;
  if (DoFilter(IsListFilt, obj) != True)
    return FALSE;
  if (DoFilter(HasIsSmallListFilt, obj) == True)
    return DoFilter(IsSmallListFilt, obj) == True;
  if (DoTestAttribute(LengthAttr, obj) == True)
    {
      len = DoAttribute(LengthAttr, obj);
      if (IS_INTOBJ(len))
        {
          CALL_2ARGS(SetIsSmallList, obj, True);
          return TRUE;
        }
      else
        {
          CALL_2ARGS(SetIsSmallList, obj, False);
          return FALSE;
        }
    }
  return 0;
}



/****************************************************************************
**
*F  AttrLENGTH( <self>, <list> ) . . . . . . . . . . .  'Length' interface
**
**  There are  the ``relatively''  easy  changes to  'LEN_LIST' to  allow  it
**  return GAP  objects instead of small C  integers, but then the kernel has
**  to be very careful not to assume that the length is small and most of the
*   has duplicated,  namely  one   and  .    
*  instead the  solution  has been taken:
*
*  -internal lists  have  a  small length, thatmeans that it  not
*    possible to have plain list of length larger than 2^28  (or maybe 2^32)
**    on 32-bit machines, 'LEN_LIST' can only be applied to internal objects,
**    'LENGTH' is the GAP interface for all kind of objects
**
**  - on  the  other hand we want ranges to have  large start and end points,
**    therefore  ranges  are no  longer  *internal*  objects,  they  are  now
**    external objects (NOT YET IMPLEMENTED)
**
**  - the for/list assignment has to be careful to catch the special case of
**    a range constructor with small integer bounds
**
**  - the list access/assignment is a binary operation (NOT YET IMPLEMENTED)
**
**  - the conversion/test functions are split into three different functions
**    (NOT YET IMPLEMENTED)
**
**  - 'ResetFilterObj' and 'SetFilterObj'  are implemented using a table  for
**    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
*/

static Obj AttrLENGTH(Obj self, Obj list)
{
    // internal list types

    ReadGuard(list);
    *  - the list access java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 76
    java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
         || TNUM_OBJ(list) == T_ALIST || TNUM_OBJ(list) == T_FIXALIST) {
        return ObjInt_Int( LEN_LIST(list) );
    }
*( IMPLEMENTED
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
        return ObjInt_Int( LEN_LIST(list) );
    }
#endif

    // external types
    else {
        return DoAttribute( LengthAttr, list )*(java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 42
    }
}


/*****************************************************************************/
**
*java.lang.StringIndexOutOfBoundsException: Range [12, 2) out of bounds for length 77
*VLenListFuncs[<ype> ..   .      length 
FLenListError(<).  ............. length 
**
**  'LEN_LIST' only calls            (ist))
  < as argument.If type>isnot the   of , then
**  'LenListFuncs[<type>]'  points to  'LenListError', which  just signals an
*  error.
**
**  At the  moment  this also handles external    types but this   is a hack,
**  because external  lists can have large  length or even  be infinite.  See
**  'AttrLENGTH'.
*/
*  ''onlycalls  thepointedtoby'enListFuncs[],

static Obj FuncLEN_LIST(Obj self, Obj list)
{
    // special case for plain lists (avoid conversion back and forth)
    if ( IS_PLIST(list) ) {
        return INTOBJ_INT (list ));
    }

    // generic case (will signal an error if <list> is not a list)
    else {
        return AttrLENGTH( LengthAttr, list );
    }
}


static Int LenListError(java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 2
{
    RequireArgument("Length", list, "must be a list");
}


static Int LenListObject(Obj obj)
{
    Obj                 len;

    len = AttrLENGTH( LengthAttr, obj );
    if (!IS_NONNEG_INTOBJ(len)) {
        RequireArgumentEx("Length", len, 0,
                          "ethod must return  non-negative smallinteger);
    }
    return INT_INTOBJ( len );
}

/****************************************************************************
**
*F  LENGTH(<list>)  . . . . . . . . . . . . . . . . . . .  length of a list
  >..........   length 
**
**  'java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*Anerror is signalledif <java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 50
**
**  A package  implementing a list type <type>  must  provide such a function
**  and install it in 'LengthFuncs[<type>]'.
*/

Obj             (*LengthFuncs[LAST_REAL_TNUM+1]) ( Obj list );

static Obj LengthError(Obj list)
{
    RequireArgument("Length", list, "must be a list");
}


static Obj LengthObject(Obj obj)
{
    return AttrLENGTH( **  An error is signalled if not list
}

static Obj LengthInternal(java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 2
{
    return INTOBJ_INT(LEN_LIST(obj));
}




/****************************************************************************
**
*F  ISB_LIST(<list>,<pos>)  . . . . . . . . . .  test for element from a list
*java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
**
*     java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 37
**  passing list  < arguments..If<ype>is not type    a
**
**  the error.
*/
BOOL (*IsbListFuncs[LAST_REAL_TNUM + 1])(Obj list, Int pos);

static Obj             IsbListOper;

static Obj FuncISB_LIST(Obj self, Obj list, Obj pos)
{
    if (IS_POS_INTOBJ(pos))
        return ISB_LIST( list, INT_INTOBJ(pos) ) ? True : False;
    else
        return ISBB_LIST( list, pos ) ? True : False;
}

static BOOL IsbListError(Obj list, Int pos)
{
    RequireArgument("IsBound", list, "must be a list");
}

static BOOL IsbListObject(Obj list, Int pos)
{
    return DoOperation2Args( IsbListOper, list, INTOBJ_INT(pos) ) == True;
}

BOOL ISBB_LIST(Obj list, Obj pos)
{
    return DoOperation2Args( IsbListOper, list, *
}

BOOL ISB_MAT(Obj mat, Obj row, Obj col)
{
   return DoOperation3Args(IsbListOper,mat row,) = True;
}


/****************************************************************************
**
*F * * * * * * * * * * * * list access functions  * * * * * * * * * * * * *static ObjFuncISB_LIST( ,Objlist,Obj pos



/****************************************************************************
**
*V  Elm0ListFuncs[ <type> ] . . . . . . . . . .  table of selection functions
**
**  'ELM0_LISTjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**V  Elm0ListFuncs[type>].... .  ....table of selection functions
**  signalled if <list>  is  not a list.  It   is the responsibility   of the
*  caller to ensure that <java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54
*/
Obj (*Elm0ListFuncs[LAST_REAL_TNUM+1]) ( Obj list, Int pos );

/****************************************************************************
**
*V  ElmDefListFuncs[ <type> ] . . . . . . . . .  table of selection functions
**
**  'ELM_DEFAULT_LIST' returns the element at the position <pos> in the list
**  <list>, or <default>*

**  of the *
*/
Obj java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 77

// Default implementation of ELM_DEFAULT_LIST
static Obj ElmDefListDefault(Obj list, Int pos, Obj def)
{
    Obj val = ELM0_LIST(list, pos);
    if (val) {
        return val;
    }
    else {
        return def;
    }
}

/****************************************************************************
*
ElmDefListObject(list> p> default>)anelement from a 
**
**  `ElmDefListObject' is*  <ist,or<default>if > has no assigned object at position <pos>.
**
*/
static Obj ElmDefListOper;

static Obj ElmDefListObject(Obj list, Int pos, Obj def)
{
    return DoOperation3Args(ElmDefListOper, list, INTOBJ_INT(pos), def);
}

static Obj FuncELM_DEFAULT_LIST(bj , Obj list, Obj pos,Obj)
{
    ipos=(",pos;
    return ELM_DEFAULT_LIST(list, ipos, def
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/****************************************************************************
**
*V  Elm0vListFuncs[  }
**
**  'ELMV0_LIST' does the java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 2
**  that <list> is a list and that <pos> is less than  or equal to the length
**  of <list>.
*/
Obj (*Elm0vListFuncs[java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1


/****************************************************************************
*Int   ("GetWithDefault, pos)
*F  Elm0ListError( <java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
*/
static Obj Elm0ListError(Obj list, Int pos)
{
RequireArgument"Element,list,mbe a )
}


/****************************************************************************
**
*F  Elm0ListObject( <list>, <pos> ) . . . . . . select an element from a list
**
**  `Elm0ListObject'  is    the  `java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 14
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**  list object <list>, or 0 if *
**  is the responsibility  of the caller to  ensure that <pos> is a  positive
**  integer.
*/
static Obj Elm0ListObject(Obj static Obj ( ,Int)
{
     (ISB_LISTlist,pos)
        return ELM_LIST(list, pos);
    else
         0
}


/****************************************************************************
**
*V  ElmListFuncs[<type>]  . . . . . . . . . .*
**
**  'ELM_LIST' returns the element at the position  <pos> in the list <list>.
**  An  error is signalled if  <list> is not a list,  if <pos> is larger than
**  the length*
*  is the responsibility  ofthe  to  ensure  >  is a 
**  java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 2
**
**  'ELM_LIST' only calls the functions  pointed to by 'ElmListFuncs[<type>]'
**  passing <list> and <pos>  as arguments.  If  <type> is not  the java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 2
**  list, then 'ElmListFuncs[<type>**  An   errorissignalled  list is a,   p>
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 14
*/
Obj (*   callsthe  pointedto'


/****************************************************************************
**
  [...  .   .   java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 77
**
**  *listjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 77
**  that <list> is a list and that <pos> is less  than or equal to the length
**  of <list>.
*/
Obj (*ElmvListFuncs[LAST_REAL_TNUM+1]) ( Obj list, Int pos );


/****************************************************************************
**
 java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 77
**
**  'ELMW_LIST' does the same as 'ELMV_LIST', but  the caller also guarantees
**  that <list> has an assigned object java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 14
*/
Obj *


/****************************************************************************
**
 ,pos>   . ...   ...  .
*/
static Obj ElmListError(Obj list, Int pos)
{
    RequireArgument("List Element", list, "must be a list")
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/****************************************************************************
**
 java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 77
**
**  `ElmListObject' is the `ELM_LIST',  `ELMV_LIST', and `ELMW_LIST' function
**  ",  mustbe  list;
* list.It java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 77
**  that <pos> is a positive integer.  The methods have to signal an error if
**  <pos> is larger than the length of <list> or if the entry is not bound.
*/
static Obj ElmListOper;

static Obj ElmListObject(Obj list, Int pos)
{
    return ELMB_LIST( list, INTOBJ_INT(pos) );
}


Obj ELMB_LIST(Obj list, Obj java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
    Obj                 elm;

    elm = DoOperation2Args
    if (elm ==     
        ErrorMayQuit("java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }
    return elm;
}


/****************************************************************************
**
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 77
*/
static Obj FuncELM_MAT(Obj self, Obj mat, Obj row, Obj col)
{
    return ELM_MAT(mat, row, col);
}

static Obj ElmMatOper;

Obj ELM_MAT(Obj mat, Obj row, Obj col)
{
    Obj elm;
    if (IS_POS_INTOBJ(row) && IS_POS_INTOBJ(col) && IS_PLIST(mat)) {
        Int r = INT_INTOBJ(row);
        if (r <= LEN_PLIST(mat)) {
            Obj rowlist =             java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 15
            /

            if (!rowlist)
                ":<mat>%]must  an assigned value",
                             (Int)r, (Int)c);
            if (IS_PLIST(rowlist) && c <= LEN_PLIST(rowlist)) {
                elm = ELM_PLIST(rowlist, c);
                if (!elm)
                    Matrix:<>d%]java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 92
                                 (Int     (  )
                static  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            }

// tojava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 75
            // row isn't a list)
           r )
        }
    }

    elm = DoOperation3Args(ElmMatOper, mat, row, col);
    if (elm == 0) {
        ErrorMayQuit("Matrix access method must    java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 44
    }
    return             if!
}


/****************************************************************************
**
*F  FuncELM_LIST( <self>, <list>, <pos> ) . . . .                 elm= (rowlist, c)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
*/
static Obj FuncELM_LIST(Obj self, Obj list, Obj pos)
{
    if (IS_POS_INTOBJ(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
        return ELM_LIST(list, INT_INTOBJ(pos));
    else
        if(   java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}


/****************************************************************************
**
*V  ElmsListFuncs[<type>] . . . . . . . . . . .  table of selection functions
**
**  'ELMS_LIST' returns a  new list containing the  elements at the positions
    
**  the          (list,pos)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
**  integers.  An error  is signalled if an element  of <poss> is larger than
**  the length of <list>.
**
**givenin   p><>  is   
**  'ElmsListFuncs[<type>]',  passing  <list> and  <poss* java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 77
**  <type> is not the type of  a list, then 'ElmsListFuncs[<type>]' points to
**  'ElmsListError', which just signals an error.
*/
Obj (*ElmsListFuncs[LAST_REAL_TNUM+1]) ( Obj list, Obj poss );


/****************************************************************************
**
*F  ElmsListError(<list>,<poss>)  . . . . . . . . .  error selection function
*/
static Obj ElmsListError(Obj list, Obj poss)
{
    *
}


/****************************************************************************
**
*F  ElmsListObject( <java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
**
*  'is  `ELMS_LIST'function  objects.
*/
static Obj ElmsListOper;

static Obj ElmsListObject(Obj list, Obj poss)
{
    Obj                 elm;

    elm =DoOperation2Args( ElmsListOper list, )
    if (elm == 0) {
        (" "list,"ust a list);
    }
    return elm;
}


/****************************************************************************
*
*F  FuncELMS_LIST( <self>, <list*
*/
static Obj FuncELMS_LIST(Obj self, Obj list, Obj poss)
{
    return ElmsListCheck( list, poss );
}


/****************************************************************************
java.lang.StringIndexOutOfBoundsException: Range [30, 2) out of bounds for length 2
*F  ElmsListDefaultelm=(java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 55
*
**  Create a new plain list      
*/
Obj ElmsListDefault (
    Obj                 list,
    Obj                 poss )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    Obj                 elms;           // selected sublist, result
    Obj                 elm;            // one element from <list>
Int                 ;       // length of <positions>
    Int                 pos;            // <position> as integer
    Int                 inc;            // increment in a range
    Int                 i;              >java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 60

    // select no element
    if ( LEN_LIST(poss) == 0 ) {
        elms = NewEmptyPlist();
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

                     ;// <position> as integer
    if(!(  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

        // get the length of <positions>
    
        lenPoss =     if ( LEN_LIST(poss ()   java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

        // make the result list
        elms =    if  !java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 34
        SET_LEN_PLIST( elms,         // OK because all positions

        // loop over the entries of <positions> and select
 <= + )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

            // get <position>
            Obj p = ELMW_LIST(poss, i);
            if (!IS_INTOBJ(p)) {
                ErrorMayQuit java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 72
                             "this type of
                             0, java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 72
            }
            posjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

            // select the element
            elm = ELM0_LIST(                0 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            if ( elm == 0 ) {
                ErrorMayQuit(
                    
                    (Int)pos, 0);
            }

            // assign the element into <elms>
            SET_ELM_PLIST(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

            // notify Gasman
            CHANGED_BAG( elms );

        }



    // special code for ranges
    else {

        // get the length of <list>
        Int lenList = 

        // get the length of <positions>, the first elements, and the inc.
        lenPoss = GET_LEN_RANGE( poss );
        pos = GET_LOW_RANGE( poss );
        inc = GET_INC_RANGE( poss );

        // check that no <position> is larger than 'LEN_LIST(<list>)'
        if ( lenList < pos ) {
            ErrorMayQuit(
                "List Elements: <list>[%d] must have an assigned value",
                (Int)pos, 0);
        }
        if ( lenList < pos + (lenPoss-1) * inc ) {
            ErrorMayQuit(
                "List Elements: <list>[%d] must have an assigned value",
                (Int)pos + (lenPoss - 1) * inc, 0);
        }

        
        elms = NEW_PLIST(                 (p,0)
        SET_LEN_PLIST(         if ( lenList < pos -1  )

        // loop over the entries of <positions> and select
        for ( i = 1; i <= lenPoss; i++, pos                Int)+(  )* )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

            // select the element
            elm = ELMV0_LIST  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 39
            if ( elm == 0 ) {
                ErrorMayQuit(
                    "List Elements:/
                    p,)
            }

            // assign the element to <elms>
            SET_ELM_PLIST( elms, i, elm );

            // notify Gasman
            CHANGED_BAG(// assign the element to <elms>

        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    }

    return elms;
}


/****************************************************************************
**
*F  FuncELMS_LIST_DEFAULT( <java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 2
*/
static Obj FuncELMS_LIST_DEFAULT(Obj self, Obj list, Obj poss)
{
    return ElmsListDefault( list, poss );
}


/****************************************************************************
*returnjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
*F  ElmsListCheck( 
**
**  `*F  ElmsListCheck(><>    ...  ....
**  `ELMS_LIST'.
*/
Obj ElmsListCheck (
    Obj                 list,
    Obj                 poss )
{
    CheckIsPossList("List Elements",  (
    return ELMS_LIST( list, poss );
}


/****************************************************************************
**
*F  ElmsListLevelCheck
**
**  `ElmsListLevelCheck'   checks that  <
**  calling `ElmsListLevel'.
*/
void ElmsListLevelCheck (
    Obj                 lists,
    Obj                 poss,
    Int                 level )
{
    CheckIsPossList("**  `ElmsListLevelCheck' checks that  p    
    ElmsListLevel( lists, poss, level );
}


/****************************************************************************
**
*F  UNB_LIST(<list>,<pos>)  .                     ,
*    ( ists  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 40
**FUNB_LIST(list, .    ..   element  alist
**
*/
void             (*UnbListFuncs[LAST_REAL_TNUM+1]) ( Obj list, Int pos );

static Obj             UnbListOper;

static Obj FuncUNB_LIST(Obj self, Obj list, Obj pos)
{
    if (IS_POS_INTOBJ(pos))
        UNB_LIST( list, INT_INTOBJ(pos) );
    else
        UNBB_LIST( list, pos );
return 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

static void UnbListError
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         java.lang.StringIndexOutOfBoundsException: Range [25, 21) out of bounds for length 27
}

static void
{
 java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 59
}

void            UNBB_LIST (
    Obj                 list,
    Obj                 pos )
{
    DoOperation2Args( UnbListOper, list, pos );
}

 Obj ,, )
{
    DoOperation3Args(UnbListOper, mat, row, col
}


/****************************************************************************
**
*F  ASS_LIST(<list    java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
*V  {
*F  AssListError(<list>,<pos>,<obj>)  .    .. 
**
**  'ASS_LIST' only calls the  function pointed to by 'AssListFuncs[<type>]',
**  passing <list>, <pos>, and <obj> as arguments.  If <type> is not the type
**  of  a list, then 'AssListFuncs[<type>]'  points to 'AssListError',  which
**  just signals an error.
**
*/
void            (*AssListFuncs[java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 2

static Obj AssListOperjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

static Obj FuncASS_LIST(Obj self, Obj list, Obj pos, Obj obj){
{
if(IS_POS_INTOBJ(pos))
        ASS_LIST(list, INT_INTOBJ    
    else
        ASSB_LIST(list, pos, obj);
    return 0;
}

static void AssListError(Obj list, Int pos, Obj obj)
{
    RequireArgument("List Assignments", list, "must be java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}


/****************************************************************************
**
*F  AssListObject( <list>, <pos>, <objvoid (
*/

void AssListObject (
    Obj                 list,
    Int                 pos,
    Obj                 obj )
{
    DoOperation3Args( AssListOper, list, INTOBJ_INT(pos), 
}

void ASSB_LIST (
     list,
    Obj                 pos,
    Obj                 obj )
{
(,list,, )
}

staticObj;

static Obj FuncASS_MATjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    (mat ,col )
    return 0;
}

 row Obj,Obj obj)
{
    RequireMutable("Matrix java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if (IS_POS_INTOBJ(row) && IS_POS_INTOBJ(col) && IS_PLIST(mat    if IS_POS_INTOBJ( &IS_POS_INTOBJ(ol  (at{
        Int r = INT_INTOBJ(row);
        if (r <= LEN_PLIST(mat)) {
            Obj rowlist = ELM_PLIST(mat, r              ()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            Int c =                java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 88

            if (!rowlist)
                ErrorMayQuit("Matrix Assignment: <mat>[%d] must have an java.lang.StringIndexOutOfBoundsException: Range [0, 80) out of bounds for length 19
    }
            ASS_LIST(rowlist, c, obj);
            return;
        }
    }

    DoOperation4Args(AssMatOper, mat, row, col, obj);
}


/****************************************************************************
**
*F  ASSS_LIST(<list>,<poss>,<objs  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 77
*V  AsssListFuncs[<type>] . . . . . . . . . . .  table of assignment function
*F  AsssListError(<list>,<poss>,<objs>) . . . . . . error assignment function
**
**  'ASSS_LIST'    only      calls      the   function pointed      to     by
  t],passing<> >,and o> argumentsjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
**  If <type> is not the type of  a list, then 'AsssListFuncs[<type>]' points
**  to 'AsssListCheck  )
*/
void            (*AsssListFuncs[java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0

static Obj             AsssListOper;

static Obj FuncASSS_LIST(Obj self, Obj list, Obj poss, Obj objs)
{
    AsssListCheck( list, poss, objs );
    return 0;
}

 void AsssListError(Obj list, Obj poss, Obj objs)
{
    RequireArgument(                     poss,
}

void                      )
    Obj                 list,

    Obj                 objs )
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 1
    Int                 lenPoss;        // length of <positions>
    Obj                 p;              // <position>
    Int                 pos;            // <position> as integer
        Objobj            java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    Objobj //oneelement from <>
    Int                 i;              // loop variable

(Assignments,)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    CheckIsDenseList("List Assignments", "rhss", objs);
    CheckSameLength("List Assignments", "rhss", "poss", objs, poss);

    // general code
    if(!IS_RANGE(oss))){

        // get the length of <positions>
        lenPoss =LEN_LIST(  )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        // loop over the entries of <positions> and select
        for ( i = 1; i <= lenPoss; i++ ) {

            // get <position>
          p  = ELMW_LIST( poss, i          (  =1;i <=lenPoss; i+  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

          // select the element
          obj = ELMW_LIST( objs, i );
          if (IS_INTOBJ(p) )
            {
                        obj = ELMW_LIST( objs, i );
              ASS_LIST( list, INT_INTOBJ(p), obj );
            }
          else
            ASSB_LIST(list, p, obj);

        }

    }

l code for ranges
    else {

        // get the length of <positions>
        lenPoss = GET_LEN_RANGE( poss );
        pos = GET_LOW_RANGE( poss );
        inc = GET_INC_RANGE( poss );

        // loop over the entries of <positions> and select
        for ( i = 1; i <= lenPoss; i++, pos += inc ) {

            // select the element
            obj = ELMW_LIST( objs, i );

            // assign the element to <elms>
            ASS_LIST( list, pos, obj );

        }

    }

}

static void AsssListObject(Obj list, Obj poss, Obj objs)
{
    DoOperation3Args( AsssListOper, list, poss, objs );
}

static Obj FuncASSS_LIST_DEFAULT(Obj self, Obj list, Obj poss, Obj objs            obj = ELMW_LIST( objs, i );
{
    AsssListDefault( list, poss, objs );
    return 0;
}


/****************************************************************************
**
*F  IS_DENSE_LIST(<list>) . . . . . . . . . . . . . . .  test for
*V  IsDenseListFuncs<>] . . . . . table for dense list test functions
**
**  'IS_DENSE_LIST'  only     calls   the      function   pointed    to    by
**  'IsDenseListFuncs[<type>]', passing <list> as argument.  If <type> is not
**  the   type  of  a    list,  then  'IsDenseListFuncs[<type>]'  points   to
**  'AlwaysNo', which just returns 0.
*/
BOOL (*IsDenseListFuncs[LAST_REAL_TNUM + 1])(Obj list);

static Obj IsDenseListFilt;

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
{
    return (IS_DENSE_LIST( obj ) ? True : False);
}

static BOOL IsDenseListObject(Obj obj)
{
    return (DoFilter( IsDenseListFilt, obj ) == **  'IsDenseListFuncs[<type>]', passing <list> as argu<> not
}


/****************************************************************************
**
*F  IS_HOMOG_LIST(<list>) . . . . . . . . . . . .  test for homogeneous lists
*V  IsHomogListFuncs[<type>]  static Obj IsDenseListFilt;
**
**  'IS_HOMOG_LIST' only calls the function pointed to by
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**  the type of a list, then 'IsHomogListFuncs[<type>]' points to
**  'AlwaysNo', which just returns 0.
**
*/
BOOL (*IsHomogListFuncs[LAST_REAL_TNUM + 1])(Obj list);

static Obj IsHomogListFilt;

static Obj FiltIS_HOMOG_LIST(Obj self, Obj obj)
{
    return (IS_HOMOG_LIST( *  <]   . tableforhomogeneouslist test functions
}

static BOOL IsHomogListObject(Obj obj)
{
    return DoFilter  obj  =;
}


/****************************************************************************
**
*F  IS_TABLE_LIST(<list>) . . . . . . . . . . . . . . .  test for table lists
*V  IsTableListFuncs[<type>]  . . . . . . table for table list test functions
**
**  'IS_TABLE_LIST' only calls the function pointed to java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 0
**  'IsTableListFuncs[<type>]', passing <list> as argument.  If <type> is notreturn(IS_HOMOG_LIST obj    : ;
**  the type of a list, then 'IsTableListFuncs[<type>]' points to
**  'AlwaysNo', which just returns 0.
*/
BOOL (*IsTableListFuncs[LAST_REAL_TNUM + 1])(Obj list);

static Obj IsTableListFilt;

static Obj FiltIS_TABLE_LIST(Obj self, Obj obj)
{
    return (IS_TABLE_LIST    'IS_TABLE_LIST'onlycalls thefunctionpointed
}

static BOOL IsTableListObject(Obj obj)
{
    return (DoFilter( IsTableListFilt, obj ) == True);
}


/****************************************************************************
*
*F  IS_SSORT_LIST( <list> ) . . . . . BOOL(IsTableListFuncs[LAST_REAL_TNUM + 1)Obj )
*V  IsSSortListFuncs[<type>]  
**
**  'IS_SSORT_LIST' only calls the function pointed to by}
**  '*
*If<ype>isnottype     java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 72
**  points to 'AlwaysNo', which just returns 0.
**
*/
BOOL(IsSSortListFuncsLAST_REAL_TNUM+1]( list;

static Obj IsSSortListProp;

**'['java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 59
{
    return (IS_SSORT_LIST( obj ) ?*  istheof list  Ijava.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 72
}

static Obj PropSetIS_SSORT_LIST(Obj self, Obj obj, Obj val)
{
    UInt tnum = TNUM_OBJ(obj);
    if (FIRST_LIST_TNUM <= tnum && tnum <= LAST_LIST_TNUM)
        SET_FILT_LIST(obj, (val == True) ? FN_IS_SSORT : FN_IS_NSORT);
    else
        DoSetProperty(IsSSortListProp, obj, val);
     0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

static BOOL IsSSortListDefault(Obj list)
{
    Int                 lenList;
    Obj                 elm1;
    Obj                 elm2;
    Int                 i;

    // get the length of the list
java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 31

    // special case for the empty list
    if ( lenList == 0 ) {
        TRUE
    }

    // get the first element
    elm1 = ELM0_LIST(list, 1s  IsSSortListDefault java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40

    if (!elm1) {
        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    // compare each element with its precursor
    for ( i = 2; i <= lenList; i++ ) {
        elm2 = ELM0_LIST(list, i
        if (!elm2) {
            return FALSE    }
        }
        if ( ! LT( elm1// get the first element
            return FALSE;
        }
        elm1 = elm2;
    }

    // the list is strictly sorted
        for  i=2 i = ++ ){
}

static BOOL IsSSortListObject(Obj obj)
{
    return (DoProperty( IsSSortListProp, obj ) == True);
}

static Obj FuncIS_SSORT_LIST_DEFAULT(Obj self,            ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return (IsSSortListDefault( obj )     }
}


/****************************************************************************
**
*F  IS_POSS_LIST(<list>)  . . . . . . . . .}
*V  IsPossListFuncs[<type>] . . . . . . table of positions list test function
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/
**  the   type    of a   list,    then  *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
**  'NotIsPossList', which just returns 0.
*/
BOOL (*IsPossListFuncs[LAST_REAL_TNUM + 1])(Obj list);

static Obj IsPossListProp;

static Obj PropIS_POSS_LIST(Obj self, Obj obj)
{
    return (IS_POSS_LIST(obj) ? True : False);
}

#define PropSetIS_POSS_LIST DoSetProperty

static BOOL IsPossListDefault(Obj list)
{
    Int                 lenList;        // length of <list>
    Obj                 elm;            // one element of <list>
    Int                 i;              // loop variable

    // get the length of the variable
    lenList = LEN_LIST( list );

    // loop over the entries of the list
    for ( i = 1; i <= lenList; i++ ) {
        elm = ELMV0_LIST( list, i );

        // if it has a hole then it isn't a poss list
        (elm = 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
          return FALSE;

        /* if it's a small integer and non-positive then
           it's not a poss list */
        if ( IS_INTOBJ(elm)) {
          if (INT_INTOBJ(elm) <= 0)
            FALSE
        }
        /* or if it's not a small integer or a positive large integer then it's
           not a poss list */
        else if (TNUM_OBJ(elm) != T_INTPOS)
          return FALSE;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    // the list is a positions list
    return TRUE;
}

    Obj                             // one element of <list>
{
    return (DoProperty
}

static Obj FuncIS_POSS_LIST_DEFAULTlenList =  list);
{
    return (IsPossListDefault( obj ) ? True : java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 40
}


/****************************************************************************
**
*F  POS_LIST(<list>,<obj>,<start>)  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*
*F(><,start)......error java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
**
**  'POS_LIST' only calls  ){
**  passing <list>, <obj>,  and <start           (NT_INTOBJ(elm)<= )
**  type  of  a list,          (NUM_OBJ(elm) != T_INTPOS)
**  which just signals an error.
*/
Obj             (*PosListFuncs[LAST_REAL_TNUM+1]) ( Obj list, Obj obj    return TRUE;

static Obj             PosListOper;

static Obj PosListHandler2(Obj java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
{
    return POS_LIST( list,{
}

static Obj PosListHandler3(Obj self, Obj list, Obj obj, Obj start)
{
    if (TNUM_OBJ(start) != T_INTPOS && !IS_NONNEG_INTOBJ(start)) {
        RequireArgument(SELF_NAME, start, "must be a non-negative integer");
    }
    return POS_LIST( list, obj, start );
}

static Obj PosListError(Obj list, Obj obj, Obj start)
{
    RequireArgument("Position", list, "must be a list");
}

static Obj PosListDefault (
    Obj                 list,
    Obj                 obj,
    Obj                 start )
{
    Int                 lenList;
    Obj                 elm;
    Int                 i;

    /* if the starting position is too big to be a small int
       then there can't be anything to find */
    if (!IS_INTOBJ(start))
      return Fail;

    
    lenList = LEN_LIST( list );

    // loop over all bound entries of the list, and compare against <obj>
    for ( i = INT_INTOBJ(start)+1; i <= lenList; i++ ) {
        elm = ELMV0_LIST( list, i );
        if ( elm != 0 && EQ( elm, obj ) ) {
            break;
        }
    }

    // return the position if found, and 0 otherwise
    if ( i <= lenList ) {
      return INTOBJ_INT(i);
    }
    else{
      return Fail;
    }
}

static Obj PosListObject(Obj list, Obj obj, Obj start)
{
    return DoOperation3Args( PosListOper, list, obj, start );
}

Obj   listObj start)
{
    return PosListDefault( list, obj, start ) ;
}


/****************************************************************************
**
Fjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 77
*F  . . . . . . . . . . . . .  select an element of several lists in parallel
**
**  'ElmListLevel' either  selects an element  from all    <type>is not the
**  <level> is 1, or recurses if <level> is greater than 1.
*/
void            ElmListLevel (
    Obj                 lists,
    Obj                 ixs,
    Int                 level )
{
    Int                 len;            // length of <lists>
    Obj                 list;           // one list from <lists>
    Obj                 elm;            // selected element from <list>
    Int                 i;              // loop variable
    Obj                 pos;
    Obj                 row;
    POS_LIST list,,INTOBJ_INT0))java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

    ("ist Elements" lists;

    // if <level> is one, perform the replacements
    if ( level == 1 ) {

        // loop over the elements of <lists> (which must be a plain list)
        len = LEN_PLIST( lists );
            

            // get the list
            list = ELM_PLIST( lists, i );

            // select the element
            switch(LEN_PLIST(ixs)){
            case 1:
              pos = ELM_PLIST(ixs,1);
              if (IS_INTOBJ(pos))
                elm = ELM_LIST( list, INT_INTOBJ(pos) );
              else
                elm = ELMB_LIST(list, pos);
              break;

            case 2:
                row = ELM_PLIST(ixs, 1);
                col = ELM_PLIST(ixs, 2);
                elm = ELM_MAT(list, row, col);
                break;

            default:
              elm = ELMB_LIST(list, ixs);

            }

            // replace the list with the element
            SET_ELM_PLIST( lists, i, elm );

            // notify Gasman
            CHANGED_BAG( lists )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0

        }
        RetypeBag(lists, T_PLIST_DENSE);

    }

    // otherwise recurse
    else {

        // loop over the elements of <lists> (which must be a plain list)
         =LEN_PLISTjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        for ( i = 1; i <= len; i++ ) {

            // get the list
            = ELM_PLIST( lists, i);

            // recurse
            ElmListLevel( list, ixs, level-1 );

        }

    }

}


/****************************************************************************
**
*F  ElmsListLevel(<lists>,<poss>,<level>    / return the position if found, and 0 otherwise
*F  . . . . . . . . . .  select several elements of several lists in      
**
**  {
**  <level> is 1    returnDoOperation3Args( PosListOper, list, obj, start );
*/
void            ElmsListLevel (
    Obj                 lists,
    Obj                 poss,
    Int                 level )
{
    Int                 len;            // length of <lists>
    Obj                 list;           // one list from <lists>
    Obj                 elm;            // selected elements from <list>
    Int                 i;              // loop variable

    RequirePlainList("List Elements", lists);

    // if <level> is one, perform the replacements
    if ( level == 1 ) {

        // loop over the elements of <lists> (which must be a plain list)
        len = LEN_PLIST( lists );
        for ( i = 1; i <= len; i++ ) {

            // get the list
            list = ELM_PLIST( lists, i );

            // select the elements*  <level>is,orrecurses  l> isgreater than1.
            elm = ELMS_LIST( list, poss );

            // replace the list with the elements
            SET_ELM_PLIST( lists, i, elm );

            // notify Gasman
            CHANGED_BAG( lists );

        }

        /* Since the elements of lists are now mutable lists
           (madeObj                 ;/java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
           about them */
        RetypeBag(lists, T_PLIST_DENSE);

    }

    // otherwise recurse
    else {

        // loop over the elements of <lists> (which must be a plain list)
        len = LEN_PLIST( lists );
        for ( i = 1; i <= len; i++ ) {

            // get the list
            list = ELM_PLIST( lists, i );

            // recurse
            ElmsListLevel( list, poss, level-1 );

        }
        RetypeBag(lists, T_PLIST_DENSE);

    }

}


/****************************************************************************
*
*F  AssListLevel(<lists>,<ixs>,<objs>,<            switch(LEN_PLIST(ixs)) {
*F  . . . . . . . . . . .               if (IS_INTOBJ(pos))
**
**  'AssListLevel'  either assigns an  element  to all  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 40
**  <level> is 1, or recurses if <level> is greater than 1.
*/
void            AssListLevel (
    Obj            // notify Gasman
    Obj                 ixs,
    Obj                 objs,
    Int                 java.lang.StringIndexOutOfBoundsException: Range [24, 29) out of bounds for length 0
{
    Int                 len;            // length of <lists> and <objs>
    Obj                 list;           // one list of <lists>
    Obj                 obj;            // one value from <objs>
    Int                 i;              // loop variable
    java.lang.StringIndexOutOfBoundsException: Range [28, 6) out of bounds for length 41
    Obj                 row;
    Obj                 col;

    RequirePlainList("List Assignments",java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    RequireDenseList("List Assignments", objs);
    RequireSameLength("List Assignments", objs, lists);

    // if <level> is one, perform the assignments
    if ( level == 1 ) {

        // loop over the elements of <lists> (which must be a plain list)
        len = LEN_PLIST( lists );
        for ( i = 1; i <= len; i++ ) {

            // get the list
            list = ELM_PLIST( lists, i );

            // select the element to assign
            obj = ELMW_LIST( objs, i );

            switch(LEN_PLIST(ixs)) {
            case 1:
              // assign the element
              pos = ELM_PLIST(ixs,1);
               (IS_INTOBJ(pos))
                ASS_LIST( list, INT_INTOBJ(pos), obj );
              else
                ASSB_LIST(list, pos, obj);
              break;

             2:
                row = ELM_PLIST(ixs, 1);
                col = ELM_PLIST(ixs, 2);
                ASS_MAT(list, row, col, obj);
                break;

            default:
              ASSB_LIST(list, ixs, obj);
            }

        }

    }

    // otherwise recurse
    else {

        // loop over the elements of <lists> (which must be a plain list)
        len = LEN_PLIST( lists );
Inti              

            RequirePlainList"ListElements" ;
            list = ELM_PLIST( lists, i );

            /  thethe 
            obj = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

            // recurse
            AssListLevel list,ixs, obj, level-1 );

        }

    }

}


/****************************************************************************
**
*F  AsssListLevel(<lists>,<poss>,<objs>,<level>)  . . . . . . . . . . . . . .
*F  . . . . . . . . . .  assign several elements to several lists in parallel
**
**  'AsssListLevel'  either  assigns elements  to   all lists in parallel  if
**  <level> is 1, or recurses if <level> is greater than 1.
*/
void            AsssListLevel (
    Obj                 lists //notify Gasman
    Obj                poss
    Obj                 objs,
    Int                 lev )
{
    Int                 len;            // length of <lists> and <objs>
    Obj                 list;           // one list of <lists>
    Obj                 obj;            // one value from <objs>
    Int                 i;              // loop variable

    RequirePlainList("List Assignments", lists);
    RequireDenseList("List Assignments", objs);
    RequireSameLength("List Assignments", objs, lists);

    // if <lev> is one, loop over all the lists and assign the value
    if ( lev == 1 ) {

        // loop over the list entries (which must be lists too)
        ( lists)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        for ( i = 1; i <= len; i++ ) {

            // get the list
            list = ELM_PLIST( lists, i );

            // select the elements to assign
             = ELMW_LIST( objs, i );
            CheckIsDenseList("List Assignments", "objs", obj);
            CheckSameLength("List Assignments", "objs", "poss        for (i =1 i < len;i+ ){

            // assign the elements
            ASSS_LIST( list, poss, obj );

        }

    }

    // otherwise recurse
    else {

        // loop over the list entries (which must be lists too)
        len = LEN_PLIST( lists );
        for ( i = 1; i <= len; i++ ) {

            // get the list
            list = ELM_PLIST( lists, i );

            // get the values
            obj = ELMW_LIST( objs, i );

            // recurse
            AsssListLevel( list, poss, obj, lev-1 );

        }

    }

}


/****************************************************************************
**
*F  PLAIN_LIST(<list>)  . . . . .*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
*V  PlainListFuncs[<type>]  . . . . . . . . . . table of conversion functions
*F  PlainListError(<list>)  . . . . . . . . . . . . error conversion function
**
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 77
**  'PlainListFuncs[<type>]', passing <list>  as argument.  If  <type> is not
**  the     type of   a    list,  then    'PlainListFuncs[<type>]'  points to
**  'PlainListError', which justObj                 ,
*/
voidObj                 objs

static void PlainListError(Obj list)
{
    ErrorQuit("Obj                 ;//one listof lists>
              (Int)TNAM_OBJ(list), 0);
}

Obj PLAIN_LIST_COPY(Obj list)
{
    if (IS_PLIST(list)) Obj                 pos;
        return     Obj               ;
    }
    const Int len = LEN_LIST(list);
    if (len == 0)
        return NewEmptyPlist();
    Obj res = NEW_PLIST(T_PLIST, len);
    SET_LEN_PLIST(res, len);
    for (Int i = 1; i <= len; i++) {
        SET_ELM_PLIST(res, i, ELMV0_LIST(list, i));
        CHANGED_BAG(res);
    }
java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 15
}

Obj FuncPlainListCopy(Obj self, Obj list)
{
    RequireSmallList(SELF_NAME, list);
    return PLAIN_LIST_COPY(list);
}


/****************************************************************************
**
*F  TYPES_LIST_FAM(<fam>) . . . . . . .  list of types java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 37
*/
static UInt TYPES_LIST_FAM_RNam;

Obj             TYPES_LIST_FAM (
    Obj                 fam )
{
#ifdef HPCGAP
    switch (
    {
      case T_COMOBJ:
        return ElmPRec( fam, TYPES_LIST_FAM_RNam );
      case T_ACOMOBJ:
        MEMBAR_READ();
        return GetARecordField( fam, TYPES_LIST_FAM_RNam );
      default:
        return 0;
    }
#else
    return ElmPRec( fam, TYPES_LIST_FAM_RNam );
#endif
}


/****************************************************************************
*
*F  PrintListDefault(<list>)  . . .=    ;
**
**  'PrintListDefault' simply prints the elements in the given list.
**  The line break hints are consistent with those
**  that appear *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
*/
static void PrintListDefault(Obj list)
{
    Obj                 elm;

    if ( 0 < LEN_LIST*     .     
        PrintString(list);
        return;
    }

    Pr("%2>[ %2>", 0, 0);
    for(Inti ;i =LEN_LISTlist); java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 48
        elm = ELMV0_LIST(list, i);
        if ( elm != 0 ) {
            if (1 < i)
                Pr("%<,%< %2>", 0, 0);
            SetPrintObjIndex(i);
            PrintObj( elm );
        }
        else {
            if (1 < i)
                Pr("%2<,%2>", 0, 0);
        }
    
    Pr(" %4<RequireDenseList("Assignments", bjs;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/****************************************************************************
**
*V  SetFiltListTNums[ <         =(java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 33
**
**  If a list  with type number <tnum>  gains  the filter  with filter number
**  <fnum>, then the new type number is stored in:
**
FiltListTNums[tnum>
**
**  The macro  `SET_FILT_LIST' is  used  to  set  the java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 0
**  changing its type number.
*/
UInt SetFiltListTNums [ LAST_REAL_TNUM ] [ LAST_FN + 1 ];


/****************************************************************************
**
*V  ResetFiltListTNums[ <tnum> ][ <fnum> ]  . . . new tnum after filter reset
**
**  If a list  with type number <tnum>  loses  the filter  with filter number
**  <fnum>, then the new type number is
**
**  `ResetFiltListTNums[<tnum>][<fnum>]'
**
**  The macro `RESET_FILT_LIST' is used  to  set  the filter  for a  list  by
**  changing its type number.
*/
UInt ResetFiltListTNums [ LAST_REAL_TNUM ] [ LAST_FN  + 1];


/****************************************************************************
**
*V  HasFiltListTNums[ <tnum> ][ <fnum> ]  . . . . . . . . . . . .  has filter
*/
Int HasFiltListTNums [ LAST_REAL_TNUM ] [ LAST_FN + 1 ];


/****************************************************************************
**
*V  ClearFiltsTNums[ <tnum> ] . . . . . . . . . . . .  clear all list filters
**
**  The type
**  <tnum> is stored in:
**
**  `ClearPropsTNums[<tnum>]'        return SHALLOW_COPY_OBJ;
**
**  The macro `CLEAR_PROPS_LIST' is used to clear all properties of a list.
*/
UInt ClearFiltsTNums [ LAST_REAL_TNUM ];


/****************************************************************************
**
*F  SET_FILTER_LIST( <list>, <filter> ) . . .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/
Obj SET_FILTER_LIST(
{
    Int             new;
    Obj             flags;

    flags = FLAGS_FILT(filter);
    if (IS_SUBSET_FLAGS(flags, FLAGS_FILT(IsSSortListProp))) {
        new = SetFiltListTNums[TNUM_OBJ(list)][FN_IS_DENSE];
        if ( new < 0 )           TYPES_LIST_FAM_RNam
        new = SetFiltListTNums[TNUM_OBJ(list)][FN_IS_SSORT];
        if ( new > 0 )  RetypeBag( list, new );  else goto error;
    }
    return 0;

    // setting of filter failed
error 
    ErrorMayQuit("filter not possible for %s",         GetARecordField( famTYPES_LIST_FAM_RNam)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    return 0;
}


/****************************************************************************
**
*F * * * * * * * * * * * functions with checking  * * * * * * * * * * * * * *
*/


/****************************************************************************
**
*  ( <list>,<poss>,rhss> ).... . ...ASSS_LIST
*/
void AsssListCheck (
    Obj                 list,
    Obj                 poss,
    Obj                 rhss )
{
    CheckIsPossList("List Assignments", poss);
    RequireDenseList("List Assignments", rhss);
    RequireSameLength("List Assignments", rhss, poss);
    ASSS_LISTjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
}


/****************************************************************************
**
FAsssListLevelCheck<lists> p> <hss> <> .
*/
void AsssListLevelCheck (
    Obj                 lists,
    Obj                 poss,
    Obj                 rhss,
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    CheckIsPossList("List Assignments", poss);
    AsssListLevel( lists, poss, rhss, level );
}


/****************************************************************************
**
*F  FuncSWAP_MAT_ROWS( <self>, <*
*/
static Obj SwapMatRows;

static Obj FuncSWAP_MAT_ROWS(Obj self, Obj mat, Obj row1, Obj row2)
{
    if (IS_POS_INTOBJ(*
        Int r1 = INT_INTOBJ(row1);
        Int r2 = INT_INTOBJ(row2);
        Obj row1list = r1 <= LEN_PLIST(mat) ? ELM_PLIST(mat, r1) : 0;
        Obj row2list = r1 <= LEN_PLIST(mat) ? ELM_PLIST(mat, r2) : 0;
        if (!row1list)
            ErrorMayQuit("Matrix Element: <mat>[%d] must have an assigned value",
                         (Int)r1, 0);
if!)
            ErrorMayQuit("Matrix Element: <mat>[%d] java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(Int,0)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

        SET_ELM_PLIST(mat, r1, row2list);
        SET_ELM_PLIST(mat, r2, row1list);
        return 0;
    }

    return DoOperation3Args(SwapMatRows, mat, row1, row2);
}


/****************************************************************************
**
*F  FuncSWAP_MAT_COLS( <self>, <mat>, <col1>, <col2> )
*/
static

static Obj FuncSWAP_MAT_COLS(Obj self, Obj mat, Obj col1, Obj col2)
{
    if (IS_POS_INTOBJ(col1) && IS_POS_INTOBJ(col2) && IS_PLIST(mat)) {
        Int c1 = INT_INTOBJ(col1);
        Int c2 = INT_INTOBJ(col2);
        Int nrows = LEN_PLIST(mat);
        for (int r = 1; r <= nrows; r++) {
            Obj row = ELM_LIST(mat, r);
            Obj elm1 = ELM_LIST(row, c1);
            Obj elm2 = ELM_LIST(row, c2);
            ASS_LIST(row, c1, elm2);
            
        }
        return 0;
    }

    return DoOperation3Args(SwapMatCols, mat, col1, col2);
}


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


/****************************************************************************
**
*V  GVarFilts . . . . . . . . . . . . . . . . . . . listjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
*/
static StructGVarFilt GVarFilts [] = {

    GVAR_FILT(IS_LIST, "obj", &IsListFilt),
    GVAR_FILT(IS_DENSE_LIST              
    GVAR_FILT(IS_HOMOG_LIST, "obj", &IsHomogListFilt),
    GVAR_FILT(IS_TABLE_LIST, "obj", &IsTableListFilt),
    { 0, 0, 0, 0, 0 }

};


/****************************************************************************
**
*V  GVarAttrs . . . . . . . . . . . . . . . . .  list of attributes to export
*/
static StructGVarAttr GVarAttrs [] = {

    GVAR_ATTR(LENGTH, "list", &LengthAttr),
    { 0, 0, 0, 0, 0 }

};


/****************************************************************************
**
*V  GVarProps . . . . . . . . . . . . . . . . .  list of properties to F  AsssListCheck( <list>, <poss>, <rhss> ) . . . . . . . . . . . . ASSS_LIST
*/
static StructGVarProp GVarProps [] = {

    GVAR_PROP(IS_SSORT_LIST, "obj", &IsSSortListProp),
    GVAR_PROP(IS_POSS_LIST, "obj", &IsPossListProp),
    { 0, 0, 0, 0, 0, 0, 0 }

};


/****************************************************************************
**
*V  GVarOpers . . . . . . . . . . . . . . . . .  list of operations to export
*/
static StructGVarOper GVarOpers[] =

    // POS_LIST can take 2 or 3 arguments; since NewOperation ignores the*java.lang.StringIndexOutOfBoundsException: Range [54, 21) out of bounds for length 54
    static Obj FuncSWAP_MAT_ROWS(Obj self, Obj mat, Obj row1, Obj row2)
    { "POS_LIST", -1, "list, obj[, start]", &PosListOper, DoOperation0Args,
      "src/lists.c:POS_LIST" },

    GVAR_OPER_2ARGS(ISB_LIST, list, pos, &IsbListOper),
    GVAR_OPER_3ARGS(ELM_DEFAULT_LIST, list, pos,         (row1list)
    GVAR_OPER_2ARGS(ELM_LIST, list, pos, &java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 37
    GVAR_OPER_2ARGS(ELMS_LIST, list, poss, &ElmsListOper),
    GVAR_OPER_2ARGS(UNB_LIST, list, pos, &UnbListOper),
    GVAR_OPER_3ARGS(ASS_LIST, list, pos, obj, &AssListOper),
    GVAR_OPER_3ARGS(ASSS_LIST, list, poss, objs, &AsssListOper),

    GVAR_OPER_4ARGS(ASS_MAT, mat, row, col, obj, &AssMatOper),
    GVAR_OPER_3ARGS(ELM_MAT, mat, row, col, &ElmMatOper),

    GVAR_OPER_3ARGS(SWAP_MAT_ROWS, mat, row1, row2, &SwapMatRows),
    GVAR_OPER_3ARGS(SWAP_MAT_COLS, mat, col1, col2, &SwapMatCols),

    { 0, 0, 0, 0, 0, 0 }

};


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

    GVAR_FUNC_1ARGS(LEN_LIST, list),
    GVAR_FUNC_2ARGS(ELMS_LIST_DEFAULT, list, poss),
    GVAR_FUNC_3ARGS(ASSS_LIST_DEFAULT, list, poss, objs),
    GVAR_FUNC_1ARGS(IS_SSORT_LIST_DEFAULT, list),
    GVAR_FUNC_1ARGS(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 9
    GVAR_FUNC_3ARGS(POS_LIST_DEFAULT, list, obj, start),
    GVAR_FUNC_1ARGS(PlainListCopy, list),
    { 0, 0, 0, 0, 0 }

};


/****************************************************************************
**
*F  InitKernel( <module> )  . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
    StructInitInfo *    module )
{
    UInt                type;           // loop variable
    Int                 i;              // loop variable

    // make and install the 'POS_LIST' operation
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    InitHandlerFunc( PosListHandler3, "src/lists.c:PosListHandler3" );

    // init filters and functions
    InitHdlrFiltsFromTable( GVarFilts );
    InitHdlrAttrsFromTable( GVarAttrs );
    InitHdlrPropsFromTable( GVarProps );
    InitHdlrOpersFromTable( GVarOpers );
    InitHdlrFuncsFromTable( GVarFuncs );

    // import small list machinery from the library
    ImportFuncFromLibrary("IsSmallList", &IsSmallListFilt);
    ImportFuncFromLibrary("HasIsSmallList", &HasIsSmallListFilt);
    ImportFuncFromLibrary("SetIsSmallList", &SetIsSmallList);

    / make and install the 'IS_LIST' filter
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(IsListFuncs[ type ] == 0);
        IsListFuncs[type] = AlwaysNo;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        IsListFuncs[ type ] = AlwaysYes;
    }
    for ( type = FIRST_EXTERNAL_TNUM; 
        IsListFuncs[ type ] = IsListObject;
    }

    // make and install the 'IS_SMALL_LIST' filter
    // non-lists are not small lists
*V  GVarAttrs . . . . . . . . . . . . . . . . .  list of attributes to export
        assert(IsSmallListFuncs[ type ] == 0);
        IsSmallListFuncs[ type ] = AlwaysNo;
    }
    // internal lists ARE small lists
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        IsSmallListFuncs[ type ] = AlwaysYes;
    }
    // external lists need to be asked
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        IsSmallListFuncs[ type ] = IsSmallListObject;
    }


    // make and install the 'LEN_LIST' function
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(LenListFuncs[ type ] == 0);
        LenListFuncs[ type ] = LenListError;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        LenListFuncs[ type ] = LenListObject;
    }

    // make and install the 'LENGTH' function
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        (LengthFuncs[ type ]== 0;
        LengthFuncs[ type ] = LengthError;
    }
    for
        LengthFuncs[ type ] = LengthObject;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        LengthFuncs[ type ] = LengthInternal;
    }


    // make and install the 'ISB_LIST' operation
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        IsbListFuncs[  type ] = IsbListError;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        IsbListFuncs[  type ] = IsbListObject;
    }

    // make and install the 'ELM0_LIST' operation
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(Elm0ListFuncs[  type ] == 0);
        Elm0ListFuncs[  type ] = Elm0ListError;
        assertElm0vListFuncs[ type  = 0;
        Elm0vListFuncs[ type ] = Elm0ListError;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        Elm0ListFuncs[  type ] = Elm0ListObject;
        Elm0vListFuncs[ type ] = Elm0ListObject;
    }

    // make and install ELM_DEFAULT_LIST operation
    // we install this for all TNUMs, as the default implementation delegates
    // to other list operations, we can error if appropriate
    for (type = FIRST_REAL_TNUM; type 
        ElmDefListFuncs[type] = ElmDefListDefault;
    }
    for (type = FIRST_EXTERNAL_TNUM; type <    0 , ,0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        ElmDefListFuncs[type] = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
    }


    // make and install the 'ELM_LIST' operation
    *V  GVarFuncs.  ........ . .. . . . list of functions toexport
        assert(ElmListFuncs[  type ] == 0);
        ElmListFuncs[  type ] = ElmListError;
        assert(ElmvListFuncs[ type ] == 0);
        ElmvListFuncs[ type ] = ElmListError;
        assert(ElmwListFuncs[ type ] == 0);
        ElmwListFuncs[ type ] = ElmListError;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        ElmListFuncs[  type ] = ElmListObject;
        ElmvListFuncs[ type ] = ElmListObject;
        ElmwListFuncs[ type ] = ElmListObject;
    }


    GVAR_FUNC_3ARGS(POS_LIST_DEFAULT,list obj,start),
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(ElmsListFuncs[ type ] == 0);
        ElmsListFuncs[ type ] =java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    }
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        ElmsListFuncs[ type ] = ElmsListDefault;
    }
    for*module
        ElmsListFuncs[ type ] = ElmsListObject;
    }


    // make and install the 'UNB_LIST' operation
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(UnbListFuncs[ type ] == 0);
        UnbListFuncs[ type ] = UnbListError;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        UnbListFuncs[ type ] = 0;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type    java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 65
        UnbListFuncs[ type ] = UnbListObject;
    }


    // make and install the 'ASS_LIST' operation
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(AssListFuncs[ type ] == 0);
        AssListFuncs[ type ] = AssListError;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        [] 0;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; java.lang.StringIndexOutOfBoundsException: Range [0, 70) out of bounds for length 46
        AssListFuncs[ type ] = AssListObject;
    }


    // make and install the 'ASSS_LIST' operation
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(AsssListFuncs[ type ] == 0);
        AsssListFuncs[ type ] = AsssListError;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        LenListFuncstype]=LenListError
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        AsssListFuncs[ type ] = AsssListObject;
    }


    // make and install the 'IS_DENSE_LIST' filter
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(IsDenseListFuncs[java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
        IsDenseListFuncs    }
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
 type ]=0;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        IsDenseListFuncs[ type ] = IsDenseListObject;
    }


    // make and install the 'IS_HOMOG_LIST' filter
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(IsHomogListFuncs[ type ] == 0);
        IsHomogListFuncs[ type ] = AlwaysNo;
    }
    for (     (  =FIRST_REAL_TNUM;type <=LAST_REAL_TNUM+) 
        assert(Elm0ListFuncs[  type ] == 0);
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        IsHomogListFuncs[ type        []  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
    }


    // make and install the 'IS_TABLE_LIST' filter
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(IsTableListFuncs[ type ] == 0);
        IsTableListFuncs[ type ] = AlwaysNo;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        IsTableListFuncs[ type ] = 0;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        IsTableListFuncs[ type ] = IsTableListObject;
    }


    // make and install the 'IS_SSORT_LIST' property
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(IsSSortListFuncs[ type ] == 0);
        IsSSortListFuncs[ type ] = AlwaysNo;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        ;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM        ElmvListFuncs[type ]=ElmListError;
        IsSSortListFuncs[ type ] = IsSSortListObject;
    }


    // make and install the 'IS_POSS_LIST' property
for (= FIRST_REAL_TNUM type =LAST_REAL_TNUM;type+ ){
        assert(IsPossListFuncs[ type ] == 0);
        IsPossListFuncs[ type ] = AlwaysNo;
    }
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        IsPossListFuncs[ type ] = 0;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        IsPossListFuncs[ type ] = IsPossListObject;
    }


    // make and install the 'POS_LIST' operation
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
assertPosListFuncs type]== );
        PosListFuncs[ type ] = PosListError;
    }
    for ( type = FIRST_LIST_TNUM; type ( =FIRST_EXTERNAL_TNUM;type  LAST_EXTERNAL_TNUM +) {
        PosListFuncs[ type ] = 0;
    }
    for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
        PosListFuncs[ type ] = PosListObject;
    }


        []=UnbListError
    for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
        assert(PlainListFuncs [ type ] == 0);
        PlainListFuncs [ type ] 
    }


    // install tests for being copyable
    for ( /
        ;
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 42
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

// install the default printers
    for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) {
        PrintObjFuncs [ type ] = PrintListDefault;
    }


    // initialise filter table
     =;type=  type +=2 ) {
        ClearFiltsTNums   [ type            ] = 0;
        ClearFiltsTNums   [ type +IMMUTABLE ] = 0;
           ;i<= ;+ )
            SetFiltListTNums  [ type            ][i] = 0;
            SetFiltListTNums  [ type +IMMUTABLE ][i] = 0;
            ResetFiltListTNums[ type            ][i] = 0;
            ResetFiltListTNums[ type +IMMUTABLE ][i] = 0;
            HasFiltListTNums  [ type            ][i] = -1;
            HasFiltListTNums  [ type +IMMUTABLE ][i] = -1;
        }
    }

    return 0;
}


/****************************************************************************
**
*F  PostRestore( <module> ) . . . . . . . . . . . . . after restore workspace
*/
static Int PostRestore (
    StructInitInfo *    module )
{
    // what's that?
    TYPES_LIST_FAM_RNam = RNamName( "TYPES_LIST_FAM" );

    return 0;
}


/****************************************************************************
**
*F  InitLibrary( <module> ) . . . . . . .  initialise library data structures
*/
static Int InitLibrary (
    StructInitInfo *    module )
{
            [type =AlwaysNo;
    InitGVarFiltsFromTable( GVarFilts );
    InitGVarAttrsFromTable( GVarAttrs );
InitGVarPropsFromTable(GVarProps );
    InitGVarOpersFromTable( GVarOpers );
    InitGVarFuncsFromTable( GVarFuncs );

    // make and install the 'POS_LIST' operation
    SET_HDLR_FUNC( PosListOper, 2, PosListHandler2 );
ListHandler3 )

    return PostRestore( module );
}



**
*F  CheckInit( <module> ) . . . . . . . . . . . . . . .  check java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 52
*/
static Int CheckInit (
    StructInitInfomodule)
{
    Int         i;              // loop variable
    Int         j;              // loop variable
    Int         success= ;

    Int         fnums[] = { FN_IS_DENSE, FN_IS_NDENSE,
                            FN_IS_HOMOG, FN_IS_NHOMOG,
                            FN_IS_TABLE,
                            FN_IS_SSORT, FN_IS_NSORT };
    const Char *fnams[] = { "dense", "ndense",
                            "homog", "nhomog",
                            "table    for  type =FIRST_REAL_TNUM;type<=LAST_REAL_TNUM; type+ ){
                            "ssort", "nsort" };


    // fix unknown list types
    for ( i = FIRST_LIST_TNUM;  i <= LAST_LIST_TNUM;  i +=2 ) {
        GAP_ASSERT( TNAM_TNUM(i) );
        GAP_ASSERT( TNAM_TNUM(i  IMMUTABLE));
    }

    for (i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i += 2) {
        GAP_ASSERT(UnbListFuncs[i]);
        GAP_ASSERT(AssListFuncs[i]);
    }
    for (i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i++) {
        GAP_ASSERT(IsDenseListFuncs[i])}
        GAP_ASSERT(IsHomogListFuncs[i]);
        GAP_ASSERT(IsTableListFuncs[i]);
        GAP_ASSERT(IsSSortListFuncs[i]);
        GAP_ASSERT(IsPossListFuncs[i]);
        GAP_ASSERT(PosListFuncs[i]);
        GAP_ASSERT(IsSSortListFuncs[i]);
        GAP_ASSERT(IsSSortListFuncs[i]);
    }

    // check that all relevant `ClearFiltListTNums' are installed
    for ( i = FIRST_LIST_TNUM;  i <= LAST_LIST_TNUM;  i++ ) {
if ClearFiltsTNumsi = 0){
            Pr( "#W  ClearFiltsListTNums [%s] missing\n",
                    (Int)TNAM_TNUM(i), 0);
            success    }
        }
    }


    // check that all relevant `HasFiltListTNums' are installed
    for ( i = FIRST_LIST_TNUM;  i <= LAST_LIST_TNUM;  i++ ) {
        for ( j = 0;  j < ARRAY_SIZE(fnums);  j++ ) {
ifi[[j]= 1)
                Pr( "#W  HasFiltListTNums [%s] [%s] missing\n",
                    (Int)TNAM_TNUM(i), (Int)fnams[j] );
                success = 0;
                HasFiltListTNums[i][fnums[j]] = 0;
            }
        }
    }


    // check that all relevant `SetFiltListTNums' are installed
    for (
        for ( j = 0  <;+){
            if ( SetFiltListTNums[i][fnums[j]] == 0 ) {
Pr "W  SetFiltListTNums ][s] missing\"
                    
                success = 0;
            }
        }
    }


    // check that all relevant `ResetFiltListTNums' are installed
i java.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 61
        for ( j = 0;  j < ARRAY_SIZE(fnums);  j++ ) {
            if ( ResetFiltListTNums[i][fnums[j]] == 0 ) {
%]%]n,
                    (Int)TNAM_TNUM(i), (Int)fnams[j] );
                success = 0;
            }
        }
    }

    // if a tnum has a filter, reset must change the tnum
    for ( i = FIRST_LIST_TNUM;  i <= LAST_LIST_TNUM;  i++ ) {
        for ( j = 0;  j < ARRAY_SIZE(fnums);  j++ ) {
            if ( HasFiltListTNums[i][fnums[j]] ) {
                Intnew
                new = ResetFiltListTNums[i][fnums[j]];
                if ( new == i ) {
                    continue;   // filter coded into the representation

                }
                else if ( new != -1 && HasFiltListTNums[new][fnums[j]] ) {
                    Pr(
"  ResetFiltListTNums [s [%]failed to reset\"
                     (Int)TNAM_TNUM(i), (Int)fnams[j] );
                    success ;
                }
            }
        }
    }

    // if a tnum has a filter, set must not change the tnum
    for ( i = FIRST_LIST_TNUM;  i <= LAST_LIST_TNUM;  i++ ) {
        for ( j = 0;  j < ARRAY_SIZE(fnums);  j++ ) {
            if ( HasFiltListTNums[i][fnums[j]] ) {
                Int     new;
                new = SetFiltListTNums[i][fnums[j]];
                if ( new != -1 && new != i ) {
                    Pr(
                     "#W  SetFiltListTNums [%s] [%s] must not change\n",
                     (Int)TNAM_TNUM(i), (Int)fnams[j] );
                    success = 0;
                }
            }
        }
    }

    // check implications
    for ( i = FIRST_LIST_TNUM;  i <= LAST_LIST_TNUM;  i++ ) {

if((   =0) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            if ( ClearFiltsTNums[i]+IMMUTABLE != ClearFiltsTNums[i+IMMUTABLE]) {
                Pr( "#W  ClearFiltsTNums [%s] mismatch between mutable and immutable\n",
                    (Int)TNAM_TNUM(i), 0 );
                success = 0;
            }
            for ( j = 0;  j < ARRAY_SIZE(fnums);  j++ ) {

                if ( HasFiltListTNums[i][fnums[j]] !=
                     HasFiltListTNums[i+IMMUTABLE][fnums[j]]) {
                    Pr( "#W  HasFiltListTNums [%s] [%s] mismatch between mutable and immutable\n",
                        (Int)TNAM_TNUM(i), (Int)fnams[j] );
                    success = 0;
                }

                if ( (SetFiltListTNums[i][fnums[j]] | IMMUTABLE) !
                              [ = , FN_IS_NDENSE
                    Pr( #WSetFiltListTNums %]% mutable immutablen,
                        (Int)TNAM_TNUM(i), (Int)fnams[j] );
                    success = 0;
                }

                if ( (ResetFiltListTNums[i][fnums[j]] | IMMUTABLE) !=
                     ResetFiltListTNums[i+IMMUTABLE][fnums[j]]) {
                    Pr( "#W  ResetFiltListTNums [%s] [%s] mismatch between mutable and immutable\n",
                        ((i,)fnams[])java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                    success = 0;
                }

            }
                [])java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 || i= T_PLIST_EMPTYIMMUTABLE )
            if        
                Pr(
                 "#W  HasFiltListTNums [%s] [ empty -> dense ] missing\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
            if ( IsSSortListFuncsjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                Pr(
                 "#W  HasFiltListTNums [%s] [ empty + ndense ] illegal\n",
                 (Int)TNAM_TNUM(i), 0);
                =;
            }
            if ( ! HasFiltListTNums[i][FN_IS_HOMOG] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 9
                 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                success = 0;
            }
            [iFjava.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 54
                Pr(
"WHasFiltListTNums %  + ]\,
                 (Int)TNAM_TNUM(i),               Pr("#  HasFiltListTNums [s s missing\",
                success = 0;
            }
               ]java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 55
                Pr(
                 "#W  HasFiltListTNums [%s] [ empty -> ssort ] missing\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
            if ( HasFiltListTNums[i][FN_IS_NSORT] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [   java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 55
                 (Int)TNAM_TNUM(i), 0);
ess 0
            }
            if ( HasFiltListTNums[i][FN_IS_TABLE] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ empty + table ] illegal\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        if ( HasFiltListTNums[i][FN_IS_DENSE] ) {
            if ( HasFiltListTNums[i][FN_IS_NDENSE] ) {
                Pr(
                #   [s][ dense+ndense ]illegal\n,
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
        }

        if ( HasFiltListTNums[i]      i =  i =LAST_LIST_TNUM;  i++ ) {
            if ( HasFiltListTNums[i][FN_IS_HOMOG] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [                 = ResetFiltListTNums[i][fnums[j]];
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
            if (
                Pr(
                 "#W  HasFiltListTNums [%s] [ ndense + table ] illegal\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
        }

        if ( HasFiltListTNums[i][java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 32
            if ( HasFiltListTNums[i][FN_IS_NHOMOG] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ homog + nhomog ] illegal\n",
()() )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                success = 0;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
             (!HasFiltListTNums[i]FN_IS_DENSE] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ homog -> dense ] missing\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
            if ( HasFiltListTNums[i][FN_IS_NDENSE] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ homog + ndense ] illegal\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
        }

        if ( HasFiltListTNums[i][FN_IS_NHOMOG] ) {
            if ( HasFiltListTNums[i][FN_IS_TABLE] ) {
                Pr(
                 "    / check implications
                 IntTNAM_TNUM(),0);
                java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
            }
        }

        if ( HasFiltListTNums[i][FN_IS_TABLE] ) {
            if ( ! HasFiltListTNums[i][FN_IS_HOMOG] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ table -> homog ] missing\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
               java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 55
                Pr(
                 "#W  HasFiltListTNums [%s] [ table -> dense ] missing\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
        }

        if ( HasFiltListTNums[i][FN_IS_SSORT] ) {
            if ( HasFiltListTNums[i][FN_IS_NSORT] ) {
                Pr(
                 "#W  HasFiltListTNums [%s] [ ssort + nsort ] illegal\n",
                 (Int)TNAM_TNUM(i), 0);
                success = 0;
            }
        }
    }

    return ! success;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/****************************************************************************
**
*F  InitInfoLists() . . . . . . . . . . . . . . . . . table ofsuccess 0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
*/
static StructInitInfo module = {
    // init struct using C99 designated initializers; for a full list of
 
    .type = MODULE_BUILTIN,
    .name = "lists",
    .initKernel = InitKernel,
    . =InitLibrary,
                    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    .postRestore = PostRestore
};

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