// ** Batch Generated with DemeterF

// ** This file was generated with DemFGen (vers:05/23/2010)

package edu.neu.ccs.demeterf.demfgen.traversals;

import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.demfgen.*;
import edu.neu.ccs.demeterf.demfgen.dgp.DGPFunc;
import edu.neu.ccs.demeterf.demfgen.traversals.Travs;
import edu.neu.ccs.demeterf.demfgen.pcdgp.PCDGPFunc;
import edu.neu.ccs.demeterf.dispatch.*;
import edu.neu.ccs.demeterf.*;
import edu.neu.ccs.demeterf.demfgen.ClassHier.InhrtPair;
import edu.neu.ccs.demeterf.demfgen.DemFGenMain;
import java.io.*;
import java.io.FileInputStream;
import edu.neu.ccs.demeterf.util.Util;
import edu.neu.ccs.demeterf.util.CLI;
import edu.neu.ccs.demeterf.demfgen.classes.Package;
import edu.neu.ccs.demeterf.demfgen.DemFGenMain;
import edu.neu.ccs.demeterf.demfgen.classes.*;

public class TypeCheckTrav {
   private TypeCheck func;
   public TypeCheckTrav(TypeCheck f){ func = f; }

   public List traverse(final List<CDFile> _h, final TypeCheck.Env _targ_){ return traverseList_CDFile_(_h, _targ_); }

   public YesGen traverseYesGen(final YesGen _h, final TypeCheck.Env _targ_){
        return func.combine((YesGen)_h);
   }
   public UseParams traverseUseParams(final UseParams _h, final TypeCheck.Env _targ_){
        NETypeUseList _types = traverseNETypeUseList(_h.getTypes(), _targ_);
        return func.combine((UseParams)_h,(NETypeUseList)_types);
   }
   public TypeUseParams traverseTypeUseParams(final TypeUseParams _h, final TypeCheck.Env _targ_){
        if(_h instanceof UseParams) return traverseUseParams((UseParams)_h, _targ_);
        if(_h instanceof EmptyUseParams) return traverseEmptyUseParams((EmptyUseParams)_h, _targ_);
        else throw new RuntimeException("Unknown TypeUseParams Variant");
   }
   public TypeUseList traverseTypeUseList(final TypeUseList _h, final TypeCheck.Env _targ_){
        if(_h instanceof TypeUseCons) return traverseTypeUseCons((TypeUseCons)_h, _targ_);
        if(_h instanceof TypeUseEmpty) return traverseTypeUseEmpty((TypeUseEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown TypeUseList Variant");
   }
   public TypeUseEmpty traverseTypeUseEmpty(final TypeUseEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((TypeUseEmpty)_h);
   }
   public TypeUseCons traverseTypeUseCons(final TypeUseCons _h, final TypeCheck.Env _targ_){
        TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_);
        TypeUseList _rest = traverseTypeUseList(_h.getRest(), _targ_);
        return func.combine((TypeUseCons)_h,(TypeUse)_first, (TypeUseList)_rest);
   }
   public TypeUse traverseTypeUse(final TypeUse _h, final TypeCheck.Env _targ_){
        ident _name = func.combine(_h.getName());
        TypeUseParams _tparams = traverseTypeUseParams(_h.getTparams(), _targ_);
        return func.combine((TypeUse)_h,(ident)_name, (TypeUseParams)_tparams, (TypeCheck.Env)_targ_);
   }
   public TypeDefParams traverseTypeDefParams(final TypeDefParams _h, final TypeCheck.Env _targ_){
        if(_h instanceof DefParams) return traverseDefParams((DefParams)_h, _targ_);
        if(_h instanceof EmptyDefParams) return traverseEmptyDefParams((EmptyDefParams)_h, _targ_);
        else throw new RuntimeException("Unknown TypeDefParams Variant");
   }
   public TypeDefList traverseTypeDefList(final TypeDefList _h, final TypeCheck.Env _targ_){
        if(_h instanceof TypeDefCons) return traverseTypeDefCons((TypeDefCons)_h, _targ_);
        if(_h instanceof TypeDefEmpty) return traverseTypeDefEmpty((TypeDefEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown TypeDefList Variant");
   }
   public TypeDefEmpty traverseTypeDefEmpty(final TypeDefEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((TypeDefEmpty)_h);
   }
   public TypeDefCons traverseTypeDefCons(final TypeDefCons _h, final TypeCheck.Env _targ_){
        TypeDef _first = traverseTypeDef(_h.getFirst(), _targ_);
        TypeDefList _rest = traverseTypeDefList(_h.getRest(), _targ_);
        return func.combine((TypeDefCons)_h,(TypeDef)_first, (TypeDefList)_rest);
   }
   public TypeDef traverseTypeDef(final TypeDef _h, final TypeCheck.Env _targ_){
        if(_h instanceof IntfcDef) return traverseIntfcDef((IntfcDef)_h, _targ_);
        if(_h instanceof ClassDef) return traverseClassDef((ClassDef)_h, _targ_);
        else throw new RuntimeException("Unknown TypeDef Variant");
   }
   public TheEOF traverseTheEOF(final TheEOF _h, final TypeCheck.Env _targ_){
        return func.combine((TheEOF)_h);
   }
   public Syntax traverseSyntax(final Syntax _h, final TypeCheck.Env _targ_){
        if(_h instanceof AddSpace) return traverseAddSpace((AddSpace)_h, _targ_);
        if(_h instanceof AddTab) return traverseAddTab((AddTab)_h, _targ_);
        if(_h instanceof AddLine) return traverseAddLine((AddLine)_h, _targ_);
        if(_h instanceof AddReturn) return traverseAddReturn((AddReturn)_h, _targ_);
        if(_h instanceof Plus) return traversePlus((Plus)_h, _targ_);
        if(_h instanceof Minus) return traverseMinus((Minus)_h, _targ_);
        if(_h instanceof AddToken) return traverseAddToken((AddToken)_h, _targ_);
        if(_h instanceof TheEOF) return traverseTheEOF((TheEOF)_h, _targ_);
        else throw new RuntimeException("Unknown Syntax Variant");
   }
   public Object traverseSubtypeList(final SubtypeList _h, final TypeCheck.Env _targ_){
        if(_h instanceof SubtypeCons) return traverseSubtypeCons((SubtypeCons)_h, _targ_);
        if(_h instanceof SubtypeEmpty) return traverseSubtypeEmpty((SubtypeEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown SubtypeList Variant");
   }
   public SubtypeEmpty traverseSubtypeEmpty(final SubtypeEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((SubtypeEmpty)_h);
   }
   public SubtypeCons traverseSubtypeCons(final SubtypeCons _h, final TypeCheck.Env _targ_){
        TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_);
        Object _rest = traverseSubtypeList(_h.getRest(), _targ_);
        return func.combine((SubtypeCons)_h,(TypeUse)_first, (SubtypeList)_rest);
   }
   public Plus traversePlus(final Plus _h, final TypeCheck.Env _targ_){
        return func.combine((Plus)_h);
   }
   public PkgStar traversePkgStar(final PkgStar _h, final TypeCheck.Env _targ_){
        return func.combine((PkgStar)_h);
   }
   public PkgList traversePkgList(final PkgList _h, final TypeCheck.Env _targ_){
        if(_h instanceof PkgCons) return traversePkgCons((PkgCons)_h, _targ_);
        if(_h instanceof PkgStar) return traversePkgStar((PkgStar)_h, _targ_);
        if(_h instanceof PkgEmpty) return traversePkgEmpty((PkgEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown PkgList Variant");
   }
   public PkgEmpty traversePkgEmpty(final PkgEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((PkgEmpty)_h);
   }
   public PkgCons traversePkgCons(final PkgCons _h, final TypeCheck.Env _targ_){
        ident _id = func.combine(_h.getId());
        PkgList _rest = traversePkgList(_h.getRest(), _targ_);
        return func.combine((PkgCons)_h,(ident)_id, (PkgList)_rest);
   }
   public PackageDef traversePackageDef(final PackageDef _h, final TypeCheck.Env _targ_){
        if(_h instanceof Package) return traversePackage((Package)_h, _targ_);
        if(_h instanceof NoPackage) return traverseNoPackage((NoPackage)_h, _targ_);
        else throw new RuntimeException("Unknown PackageDef Variant");
   }
   public Package traversePackage(final Package _h, final TypeCheck.Env _targ_){
        NEPkgList _pkg = traverseNEPkgList(_h.getPkg(), _targ_);
        return func.combine((Package)_h,(NEPkgList)_pkg);
   }
   public PESubtypeList traversePESubtypeList(final PESubtypeList _h, final TypeCheck.Env _targ_){        if(_h instanceof NESubtypeList) return traverseNESubtypeList((NESubtypeList)_h, _targ_);
        if(_h instanceof SubtypeEmpty) return traverseSubtypeEmpty((SubtypeEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown PESubtypeList Variant");
   }
   public NoParse traverseNoParse(final NoParse _h, final TypeCheck.Env _targ_){
        return func.combine((NoParse)_h);
   }
   public NoPackage traverseNoPackage(final NoPackage _h, final TypeCheck.Env _targ_){
        return func.combine((NoPackage)_h);
   }
   public NoLook traverseNoLook(final NoLook _h, final TypeCheck.Env _targ_){
        return func.combine((NoLook)_h);
   }
   public NoImpl traverseNoImpl(final NoImpl _h, final TypeCheck.Env _targ_){
        return func.combine((NoImpl)_h);
   }
   public NoGen traverseNoGen(final NoGen _h, final TypeCheck.Env _targ_){
        return func.combine((NoGen)_h);
   }
   public NoDGPUse traverseNoDGPUse(final NoDGPUse _h, final TypeCheck.Env _targ_){
        return func.combine((NoDGPUse)_h);
   }
   public NoBound traverseNoBound(final NoBound _h, final TypeCheck.Env _targ_){
        return func.combine((NoBound)_h);
   }
   public NameList traverseNameList(final NameList _h, final TypeCheck.Env _targ_){
        if(_h instanceof NameCons) return traverseNameCons((NameCons)_h, _targ_);
        if(_h instanceof NameEmpty) return traverseNameEmpty((NameEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown NameList Variant");
   }
   public NameEmpty traverseNameEmpty(final NameEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((NameEmpty)_h);
   }
   public NameDef traverseNameDef(final NameDef _h, final TypeCheck.Env _targ_){
        ident _id = func.combine(_h.getId());
        Bound _bnd = traverseBound(_h.getBnd(), _targ_);
        return func.combine((NameDef)_h,(ident)_id, (Bound)_bnd);
   }
   public NameCons traverseNameCons(final NameCons _h, final TypeCheck.Env _targ_){
        NameDef _first = traverseNameDef(_h.getFirst(), _targ_);
        NameList _rest = traverseNameList(_h.getRest(), _targ_);
        return func.combine((NameCons)_h,(NameDef)_first, (NameList)_rest);
   }
   public NETypeUseList traverseNETypeUseList(final NETypeUseList _h, final TypeCheck.Env _targ_){
        TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_);
        TypeUseList _rest = traverseTypeUseList(_h.getRest(), _targ_);
        return func.combine((NETypeUseList)_h,(TypeUse)_first, (TypeUseList)_rest);
   }
   public NESubtypeList traverseNESubtypeList(final NESubtypeList _h, final TypeCheck.Env _targ_){
        TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_);
        Object _rest = traverseSubtypeList(_h.getRest(), _targ_);
        return func.combine((NESubtypeList)_h,(TypeUse)_first, (SubtypeList)_rest);
   }
   public NEPkgList traverseNEPkgList(final NEPkgList _h, final TypeCheck.Env _targ_){
        ident _id = func.combine(_h.getId());
        PkgList _rest = traversePkgList(_h.getRest(), _targ_);
        return func.combine((NEPkgList)_h,(ident)_id, (PkgList)_rest);
   }
   public NENameList traverseNENameList(final NENameList _h, final TypeCheck.Env _targ_){
        NameDef _first = traverseNameDef(_h.getFirst(), _targ_);
        NameList _rest = traverseNameList(_h.getRest(), _targ_);
        return func.combine((NENameList)_h,(NameDef)_first, (NameList)_rest);
   }
   public Minus traverseMinus(final Minus _h, final TypeCheck.Env _targ_){
        return func.combine((Minus)_h);
   }
   public LookDef traverseLookDef(final LookDef _h, final TypeCheck.Env _targ_){
        if(_h instanceof LookAhead) return traverseLookAhead((LookAhead)_h, _targ_);
        if(_h instanceof NoLook) return traverseNoLook((NoLook)_h, _targ_);
        else throw new RuntimeException("Unknown LookDef Variant");
   }
   public LookAhead traverseLookAhead(final LookAhead _h, final TypeCheck.Env _targ_){
        Integer _n = func.combine(_h.getN());
        return func.combine((LookAhead)_h,(int)_n);
   }
   public List traverseList_CDFile_(final List<CDFile> _h, final TypeCheck.Env _targ_){
        if(_h instanceof Cons) return traverseCons_CDFile_((Cons<CDFile>)_h, _targ_);
        if(_h instanceof Empty) return traverseEmpty_CDFile_((Empty<CDFile>)_h, _targ_);
        else throw new RuntimeException("Unknown List Variant");
   }
   public IntfcDef traverseIntfcDef(final IntfcDef _h, final TypeCheck.Env _targ_){
        DoGen _gen = traverseDoGen(_h.getGen(), func.update(_h, new IntfcDef.gen(), _targ_));
        ident _name = func.combine(_h.getName());
        TypeDefParams _tparams = traverseTypeDefParams(_h.getTparams(), func.update(_h, new IntfcDef.tparams(), _targ_));
        PESubtypeList _subtypes = traversePESubtypeList(_h.getSubtypes(), func.update(_h, new IntfcDef.subtypes(), _targ_));
        return func.combine((IntfcDef)_h,(DoGen)_gen, (ident)_name, (TypeDefParams)_tparams, (PESubtypeList)_subtypes);
   }
   public IntfImpl traverseIntfImpl(final IntfImpl _h, final TypeCheck.Env _targ_){
        NETypeUseList _intf = traverseNETypeUseList(_h.getIntf(), _targ_);
        return func.combine((IntfImpl)_h,(NETypeUseList)_intf);
   }
   public IncludeList traverseIncludeList(final IncludeList _h, final TypeCheck.Env _targ_){
        if(_h instanceof IncludeCons) return traverseIncludeCons((IncludeCons)_h, _targ_);
        if(_h instanceof IncludeEmpty) return traverseIncludeEmpty((IncludeEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown IncludeList Variant");
   }
   public IncludeEmpty traverseIncludeEmpty(final IncludeEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((IncludeEmpty)_h);
   }
   public IncludeCons traverseIncludeCons(final IncludeCons _h, final TypeCheck.Env _targ_){
        Include _first = traverseInclude(_h.getFirst(), _targ_);
        IncludeList _rest = traverseIncludeList(_h.getRest(), _targ_);
        return func.combine((IncludeCons)_h,(Include)_first, (IncludeList)_rest);
   }
   public Include traverseInclude(final Include _h, final TypeCheck.Env _targ_){
        DoGen _gen = traverseDoGen(_h.getGen(), _targ_);
        String _file = func.combine(_h.getFile());
        return func.combine((Include)_h,(DoGen)_gen, (String)_file);
   }
   public ImportList traverseImportList(final ImportList _h, final TypeCheck.Env _targ_){
        if(_h instanceof ImportCons) return traverseImportCons((ImportCons)_h, _targ_);
        if(_h instanceof ImportEmpty) return traverseImportEmpty((ImportEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown ImportList Variant");
   }
   public ImportEmpty traverseImportEmpty(final ImportEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((ImportEmpty)_h);
   }
   public ImportCons traverseImportCons(final ImportCons _h, final TypeCheck.Env _targ_){
        Import _first = traverseImport(_h.getFirst(), _targ_);
        ImportList _rest = traverseImportList(_h.getRest(), _targ_);
        return func.combine((ImportCons)_h,(Import)_first, (ImportList)_rest);
   }
   public Import traverseImport(final Import _h, final TypeCheck.Env _targ_){
        NEPkgList _pkg = traverseNEPkgList(_h.getPkg(), _targ_);
        return func.combine((Import)_h,(NEPkgList)_pkg);
   }
   public Impl traverseImpl(final Impl _h, final TypeCheck.Env _targ_){
        if(_h instanceof IntfImpl) return traverseIntfImpl((IntfImpl)_h, _targ_);
        if(_h instanceof NoImpl) return traverseNoImpl((NoImpl)_h, _targ_);
        else throw new RuntimeException("Unknown Impl Variant");
   }
   public FieldOrSyntax traverseFieldOrSyntax(final FieldOrSyntax _h, final TypeCheck.Env _targ_){
        if(_h instanceof Field) return traverseField((Field)_h, _targ_);
        if(_h instanceof Syntax) return traverseSyntax((Syntax)_h, _targ_);
        else throw new RuntimeException("Unknown FieldOrSyntax Variant");
   }
   public FieldList traverseFieldList(final FieldList _h, final TypeCheck.Env _targ_){
        if(_h instanceof FieldCons) return traverseFieldCons((FieldCons)_h, _targ_);
        if(_h instanceof FieldEmpty) return traverseFieldEmpty((FieldEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown FieldList Variant");
   }
   public FieldEmpty traverseFieldEmpty(final FieldEmpty _h, final TypeCheck.Env _targ_){
        return func.combine((FieldEmpty)_h);
   }
   public FieldCons traverseFieldCons(final FieldCons _h, final TypeCheck.Env _targ_){
        FieldOrSyntax _first = traverseFieldOrSyntax(_h.getFirst(), _targ_);
        FieldList _rest = traverseFieldList(_h.getRest(), _targ_);
        return func.combine((FieldCons)_h,(FieldOrSyntax)_first, (FieldList)_rest);
   }
   public Field traverseField(final Field _h, final TypeCheck.Env _targ_){
        ident _name = func.combine(_h.getName());
        TypeUse _type = traverseTypeUse(_h.getType(), _targ_);
        return func.combine((Field)_h,(ident)_name, (TypeUse)_type);
   }
   public Extern traverseExtern(final Extern _h, final TypeCheck.Env _targ_){
        return func.combine((Extern)_h);
   }
   public EmptyUseParams traverseEmptyUseParams(final EmptyUseParams _h, final TypeCheck.Env _targ_){
        return func.combine((EmptyUseParams)_h);
   }
   public EmptyDefParams traverseEmptyDefParams(final EmptyDefParams _h, final TypeCheck.Env _targ_){
        return func.combine((EmptyDefParams)_h);
   }
   public Empty traverseEmpty_CDFile_(final Empty<CDFile> _h, final TypeCheck.Env _targ_){
        return func.combine((Empty)_h);
   }
   public DoGen traverseDoGen(final DoGen _h, final TypeCheck.Env _targ_){
        if(_h instanceof NoParse) return traverseNoParse((NoParse)_h, _targ_);
        if(_h instanceof NoGen) return traverseNoGen((NoGen)_h, _targ_);
        if(_h instanceof Extern) return traverseExtern((Extern)_h, _targ_);
        if(_h instanceof YesGen) return traverseYesGen((YesGen)_h, _targ_);
        else throw new RuntimeException("Unknown DoGen Variant");
   }
   public DefParams traverseDefParams(final DefParams _h, final TypeCheck.Env _targ_){
        NENameList _types = traverseNENameList(_h.getTypes(), _targ_);
        return func.combine((DefParams)_h,(NENameList)_types);
   }
   public DGPUses traverseDGPUses(final DGPUses _h, final TypeCheck.Env _targ_){
        if(_h instanceof DGPUse) return traverseDGPUse((DGPUse)_h, _targ_);
        if(_h instanceof NoDGPUse) return traverseNoDGPUse((NoDGPUse)_h, _targ_);
        else throw new RuntimeException("Unknown DGPUses Variant");
   }
   public DGPUse traverseDGPUse(final DGPUse _h, final TypeCheck.Env _targ_){
        NENameList _pkg = traverseNENameList(_h.getPkg(), _targ_);
        return func.combine((DGPUse)_h,(NENameList)_pkg);
   }
   public Cons traverseCons_CDFile_(final Cons<CDFile> _h, final TypeCheck.Env _targ_){
        CDFile _first = traverseCDFile(_h.getFirst(), _targ_);
        List _rest = traverseList_CDFile_(_h.getRest(), _targ_);
        return func.combine((Cons)_h,(CDFile)_first, (List<CDFile>)_rest);
   }
   public ClassDef traverseClassDef(final ClassDef _h, final TypeCheck.Env _targ_){
        DoGen _gen = traverseDoGen(_h.getGen(), func.update(_h, new ClassDef.gen(), _targ_));
        ident _name = func.combine(_h.getName());
        TypeDefParams _tparams = traverseTypeDefParams(_h.getTparams(), func.update(_h, new ClassDef.tparams(), _targ_));
        PESubtypeList _subtypes = traversePESubtypeList(_h.getSubtypes(), func.update(_h, new ClassDef.subtypes(), _targ_));
        FieldList _fields = traverseFieldList(_h.getFields(), func.update(_h, new ClassDef.fields(), _targ_));
        Impl _ext = traverseImpl(_h.getExt(), func.update(_h, new ClassDef.ext(), _targ_));
        return func.combine((ClassDef)_h,(DoGen)_gen, (ident)_name, (TypeDefParams)_tparams, (PESubtypeList)_subtypes, (FieldList)_fields, (Impl)_ext);
   }
   public ClassBound traverseClassBound(final ClassBound _h, final TypeCheck.Env _targ_){
        TypeUse _bound = traverseTypeUse(_h.getBound(), _targ_);
        return func.combine((ClassBound)_h,(TypeUse)_bound);
   }
   public CDFile traverseCDFile(final CDFile _h, final TypeCheck.Env _targ_){
        IncludeList _incl = traverseIncludeList(_h.getIncl(), _targ_);
        DGPUses _dgpuse = traverseDGPUses(_h.getDgpuse(), _targ_);
        PackageDef _pkg = traversePackageDef(_h.getPkg(), _targ_);
        LookDef _look = traverseLookDef(_h.getLook(), _targ_);
        ImportList _imports = traverseImportList(_h.getImports(), _targ_);
        TypeDefList _types = traverseTypeDefList(_h.getTypes(), _targ_);
        return func.combine((CDFile)_h,(IncludeList)_incl, (DGPUses)_dgpuse, (PackageDef)_pkg, (LookDef)_look, (ImportList)_imports, (TypeDefList)_types);
   }
   public Bound traverseBound(final Bound _h, final TypeCheck.Env _targ_){
        if(_h instanceof ClassBound) return traverseClassBound((ClassBound)_h, _targ_);
        if(_h instanceof NoBound) return traverseNoBound((NoBound)_h, _targ_);
        else throw new RuntimeException("Unknown Bound Variant");
   }
   public AddToken traverseAddToken(final AddToken _h, final TypeCheck.Env _targ_){
        String _str = func.combine(_h.getStr());
        return func.combine((AddToken)_h,(String)_str);
   }
   public AddTab traverseAddTab(final AddTab _h, final TypeCheck.Env _targ_){
        return func.combine((AddTab)_h);
   }
   public AddSpace traverseAddSpace(final AddSpace _h, final TypeCheck.Env _targ_){
        return func.combine((AddSpace)_h);
   }
   public AddReturn traverseAddReturn(final AddReturn _h, final TypeCheck.Env _targ_){
        return func.combine((AddReturn)_h);
   }
   public AddLine traverseAddLine(final AddLine _h, final TypeCheck.Env _targ_){
        return func.combine((AddLine)_h);
   }

}