// This file is automatically generated by Demeter/Java.

CopyVisitor {
  (@
    private java.util.Stack history = new java.util.Stack();
    public CopyVisitor(Class firstClass) {
      try {
        history.push(firstClass.newInstance());
      } catch(Exception e) {
        e.printStackTrace();
      }
    }
  @)
  get copy (@ return history.peek(); @)
  return Object (@ get_copy() @)


  before -> UGraph, pkg, Package (@
    UGraph it = (UGraph) history.peek();
    Package p = new Package();
    it.set_pkg(p);
    history.push(p);
  @)

  after -> UGraph, pkg, Package (@
    history.pop();
  @)

  before -> UGraph, imports, Import_SList (@
    UGraph it = (UGraph) history.peek();
    Import_SList p = new Import_SList();
    it.set_imports(p);
    history.push(p);
  @)

  after -> UGraph, imports, Import_SList (@
    history.pop();
  @)

  before -> UGraph, preamble, JavaCode (@
    UGraph it = (UGraph) history.peek();
    JavaCode p = new JavaCode();
    it.set_preamble(p);
    history.push(p);
  @)

  after -> UGraph, preamble, JavaCode (@
    history.pop();
  @)

  before -> UGraph, vertices, UVertex_List (@
    UGraph it = (UGraph) history.peek();
    UVertex_List p = new UVertex_List();
    it.set_vertices(p);
    history.push(p);
  @)

  after -> UGraph, vertices, UVertex_List (@
    history.pop();
  @)

  before -> UGraph, idToVertexTable, Hashtable (@
    UGraph it = (UGraph) history.peek();
    it.set_idToVertexTable(dest);
  @)

  before -> UGraph, edges, UEdge_List (@
    UGraph it = (UGraph) history.peek();
    UEdge_List p = new UEdge_List();
    it.set_edges(p);
    history.push(p);
  @)

  after -> UGraph, edges, UEdge_List (@
    history.pop();
  @)

  before -> UGraph, idToEdgeTable, Hashtable (@
    UGraph it = (UGraph) history.peek();
    it.set_idToEdgeTable(dest);
  @)

  before -> UGraph, nameToIdVertexTable, Hashtable (@
    UGraph it = (UGraph) history.peek();
    it.set_nameToIdVertexTable(dest);
  @)

  before -> UGraph, firstuid, UID (@
    UGraph it = (UGraph) history.peek();
    UID p = new UID();
    it.set_firstuid(p);
    history.push(p);
  @)

  after -> UGraph, firstuid, UID (@
    history.pop();
  @)

  before -> UVertex_List, first, Nonempty_UVertex_List (@
    UVertex_List it = (UVertex_List) history.peek();
    Nonempty_UVertex_List p = new Nonempty_UVertex_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> UVertex_List, first, Nonempty_UVertex_List (@
    history.pop();
  @)

  before -> UVertex, vid, UID (@
    UVertex it = (UVertex) history.peek();
    UID p = new UID();
    it.set_vid(p);
    history.push(p);
  @)

  after -> UVertex, vid, UID (@
    history.pop();
  @)

  before -> UVertex, vertexname, UVertexName (@
    UVertex it = (UVertex) history.peek();
    UVertexName p = new UVertexName();
    it.set_vertexname(p);
    history.push(p);
  @)

  after -> UVertex, vertexname, UVertexName (@
    history.pop();
  @)

  before -> UVertex, position, Coordinates (@
    UVertex it = (UVertex) history.peek();
    Coordinates p = new Coordinates();
    it.set_position(p);
    history.push(p);
  @)

  after -> UVertex, position, Coordinates (@
    history.pop();
  @)

  before -> UVertex, incoming, IEdge_List (@
    UVertex it = (UVertex) history.peek();
    IEdge_List p = new IEdge_List();
    it.set_incoming(p);
    history.push(p);
  @)

  after -> UVertex, incoming, IEdge_List (@
    history.pop();
  @)

  before -> UVertex, outgoing, OEdge_List (@
    UVertex it = (UVertex) history.peek();
    OEdge_List p = new OEdge_List();
    it.set_outgoing(p);
    history.push(p);
  @)

  after -> UVertex, outgoing, OEdge_List (@
    history.pop();
  @)

  before -> UVertex, inArcIdList, Vector (@
    UVertex it = (UVertex) history.peek();
    it.set_inArcIdList(dest);
  @)

  before -> UVertex, outArcIdList, Vector (@
    UVertex it = (UVertex) history.peek();
    it.set_outArcIdList(dest);
  @)

  before -> UVertex, vdeco, Decorator (@
    UVertex it = (UVertex) history.peek();
    Decorator p = new Decorator();
    it.set_vdeco(p);
    history.push(p);
  @)

  after -> UVertex, vdeco, Decorator (@
    history.pop();
  @)

  before -> UVertex, tgv, TGVertex (@
    UVertex it = (UVertex) history.peek();
    it.set_tgv(dest);
  @)

  before -> UVertex, persp, Perspective (@
    UVertex it = (UVertex) history.peek();
    it.set_persp(dest);
  @)

  before -> UConstOrAltVertex, parse, ParseOrNot (@
    UConstOrAltVertex it = (UConstOrAltVertex) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_parse((ParseOrNot) p);
    history.push(p);
  @)

  after -> UConstOrAltVertex, parse, ParseOrNot (@
    history.pop();
  @)

  before -> UConstOrAltVertex, outEdgeNameList, Vector (@
    UConstOrAltVertex it = (UConstOrAltVertex) history.peek();
    it.set_outEdgeNameList(dest);
  @)

  before -> UConstOrAltVertex, keywords, ScopeIdentifier_List (@
    UConstOrAltVertex it = (UConstOrAltVertex) history.peek();
    ScopeIdentifier_List p = new ScopeIdentifier_List();
    it.set_keywords(p);
    history.push(p);
  @)

  after -> UConstOrAltVertex, keywords, ScopeIdentifier_List (@
    history.pop();
  @)

  before -> IEdge_List, first, Nonempty_IEdge_List (@
    IEdge_List it = (IEdge_List) history.peek();
    Nonempty_IEdge_List p = new Nonempty_IEdge_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> IEdge_List, first, Nonempty_IEdge_List (@
    history.pop();
  @)

  before -> OEdge_List, first, Nonempty_OEdge_List (@
    OEdge_List it = (OEdge_List) history.peek();
    Nonempty_OEdge_List p = new Nonempty_OEdge_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> OEdge_List, first, Nonempty_OEdge_List (@
    history.pop();
  @)

  before -> UConstVertex, beFore, UBefore (@
    UConstVertex it = (UConstVertex) history.peek();
    UBefore p = new UBefore();
    it.set_beFore(p);
    history.push(p);
  @)

  after -> UConstVertex, beFore, UBefore (@
    history.pop();
  @)

  before -> UConstVertex, afTer, UAfter (@
    UConstVertex it = (UConstVertex) history.peek();
    UAfter p = new UAfter();
    it.set_afTer(p);
    history.push(p);
  @)

  after -> UConstVertex, afTer, UAfter (@
    history.pop();
  @)

  before -> UBefore, syntax, String (@
    UBefore it = (UBefore) history.peek();
    it.set_syntax(dest);
  @)

  before -> UAfter, syntax, String (@
    UAfter it = (UAfter) history.peek();
    it.set_syntax(dest);
  @)

  before -> UInterface, keywords, InterfaceModifier_List (@
    UInterface it = (UInterface) history.peek();
    InterfaceModifier_List p = new InterfaceModifier_List();
    it.set_keywords(p);
    history.push(p);
  @)

  after -> UInterface, keywords, InterfaceModifier_List (@
    history.pop();
  @)

  before -> UInterface, javacode, JavaCode (@
    UInterface it = (UInterface) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> UInterface, javacode, JavaCode (@
    history.pop();
  @)

  before -> InterfaceModifier_List, first, Nonempty_InterfaceModifier_List (@
    InterfaceModifier_List it = (InterfaceModifier_List) history.peek();
    Nonempty_InterfaceModifier_List p = new Nonempty_InterfaceModifier_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> InterfaceModifier_List, first, Nonempty_InterfaceModifier_List (@
    history.pop();
  @)

  before -> ScopeIdentifier_List, first, Nonempty_ScopeIdentifier_List (@
    ScopeIdentifier_List it = (ScopeIdentifier_List) history.peek();
    Nonempty_ScopeIdentifier_List p = new Nonempty_ScopeIdentifier_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> ScopeIdentifier_List, first, Nonempty_ScopeIdentifier_List (@
    history.pop();
  @)

  before -> UEdge_List, first, Nonempty_UEdge_List (@
    UEdge_List it = (UEdge_List) history.peek();
    Nonempty_UEdge_List p = new Nonempty_UEdge_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> UEdge_List, first, Nonempty_UEdge_List (@
    history.pop();
  @)

  before -> UEdge, eid, UID (@
    UEdge it = (UEdge) history.peek();
    UID p = new UID();
    it.set_eid(p);
    history.push(p);
  @)

  after -> UEdge, eid, UID (@
    history.pop();
  @)

  before -> UEdge, fromVertex, UID (@
    UEdge it = (UEdge) history.peek();
    UID p = new UID();
    it.set_fromVertex(p);
    history.push(p);
  @)

  after -> UEdge, fromVertex, UID (@
    history.pop();
  @)

  before -> UEdge, toVertex, UID (@
    UEdge it = (UEdge) history.peek();
    UID p = new UID();
    it.set_toVertex(p);
    history.push(p);
  @)

  after -> UEdge, toVertex, UID (@
    history.pop();
  @)

  before -> UEdge, edeco, Decorator (@
    UEdge it = (UEdge) history.peek();
    Decorator p = new Decorator();
    it.set_edeco(p);
    history.push(p);
  @)

  after -> UEdge, edeco, Decorator (@
    history.pop();
  @)

  before -> UEdge, bendpoint, BendPoint (@
    UEdge it = (UEdge) history.peek();
    BendPoint p = new BendPoint();
    it.set_bendpoint(p);
    history.push(p);
  @)

  after -> UEdge, bendpoint, BendPoint (@
    history.pop();
  @)

  before -> UEdge, persp, ArcPerspective (@
    UEdge it = (UEdge) history.peek();
    it.set_persp(dest);
  @)

  before -> BendPoint, position, Coordinates (@
    BendPoint it = (BendPoint) history.peek();
    Coordinates p = new Coordinates();
    it.set_position(p);
    history.push(p);
  @)

  after -> BendPoint, position, Coordinates (@
    history.pop();
  @)

  before -> UAltEdge, tge, TGAEdge (@
    UAltEdge it = (UAltEdge) history.peek();
    it.set_tge(dest);
  @)

  before -> UExtendEdge, tge, TGAEdge (@
    UExtendEdge it = (UExtendEdge) history.peek();
    it.set_tge(dest);
  @)

  before -> UImplEdge, tge, TGIEdge (@
    UImplEdge it = (UImplEdge) history.peek();
    it.set_tge(dest);
  @)

  before -> UConstEdge, edgename, UEdgeName (@
    UConstEdge it = (UConstEdge) history.peek();
    UEdgeName p = new UEdgeName();
    it.set_edgename(p);
    history.push(p);
  @)

  after -> UConstEdge, edgename, UEdgeName (@
    history.pop();
  @)

  before -> UConstEdge, card, Cardinality (@
    UConstEdge it = (UConstEdge) history.peek();
    Cardinality p = new Cardinality();
    it.set_card(p);
    history.push(p);
  @)

  after -> UConstEdge, card, Cardinality (@
    history.pop();
  @)

  before -> UConstEdge, beFore, UBefore (@
    UConstEdge it = (UConstEdge) history.peek();
    UBefore p = new UBefore();
    it.set_beFore(p);
    history.push(p);
  @)

  after -> UConstEdge, beFore, UBefore (@
    history.pop();
  @)

  before -> UConstEdge, afTer, UAfter (@
    UConstEdge it = (UConstEdge) history.peek();
    UAfter p = new UAfter();
    it.set_afTer(p);
    history.push(p);
  @)

  after -> UConstEdge, afTer, UAfter (@
    history.pop();
  @)

  before -> UConstEdge, keywords, PartModifier_List (@
    UConstEdge it = (UConstEdge) history.peek();
    PartModifier_List p = new PartModifier_List();
    it.set_keywords(p);
    history.push(p);
  @)

  after -> UConstEdge, keywords, PartModifier_List (@
    history.pop();
  @)

  before -> UConstEdge, tge, TGCEdge (@
    UConstEdge it = (UConstEdge) history.peek();
    it.set_tge(dest);
  @)

  before -> PartModifier_List, first, Nonempty_PartModifier_List (@
    PartModifier_List it = (PartModifier_List) history.peek();
    Nonempty_PartModifier_List p = new Nonempty_PartModifier_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> PartModifier_List, first, Nonempty_PartModifier_List (@
    history.pop();
  @)

  before -> Cardinality, lower, Lower (@
    Cardinality it = (Cardinality) history.peek();
    Lower p = new Lower();
    it.set_lower(p);
    history.push(p);
  @)

  after -> Cardinality, lower, Lower (@
    history.pop();
  @)

  before -> Cardinality, upper, Upper (@
    Cardinality it = (Cardinality) history.peek();
    Upper p = new Upper();
    it.set_upper(p);
    history.push(p);
  @)

  after -> Cardinality, upper, Upper (@
    history.pop();
  @)

  before -> Lower, l, Integer (@
    Lower it = (Lower) history.peek();
    it.set_l(dest);
  @)

  before -> Upper, u, String (@
    Upper it = (Upper) history.peek();
    it.set_u(dest);
  @)

  before -> UID, id, Integer (@
    UID it = (UID) history.peek();
    it.set_id(dest);
  @)

  before -> UEdgeName, name, Ident (@
    UEdgeName it = (UEdgeName) history.peek();
    it.set_name(dest);
  @)

  before -> UVertexName, name, Ident (@
    UVertexName it = (UVertexName) history.peek();
    it.set_name(dest);
  @)

  before -> Coordinates, x, X (@
    Coordinates it = (Coordinates) history.peek();
    X p = new X();
    it.set_x(p);
    history.push(p);
  @)

  after -> Coordinates, x, X (@
    history.pop();
  @)

  before -> Coordinates, y, Y (@
    Coordinates it = (Coordinates) history.peek();
    Y p = new Y();
    it.set_y(p);
    history.push(p);
  @)

  after -> Coordinates, y, Y (@
    history.pop();
  @)

  before -> X, x, Integer (@
    X it = (X) history.peek();
    it.set_x(dest);
  @)

  before -> Y, y, Integer (@
    Y it = (Y) history.peek();
    it.set_y(dest);
  @)

  before -> Decorator, travtag, Integer (@
    Decorator it = (Decorator) history.peek();
    it.set_travtag(dest);
  @)

  before -> Decorator, travtaglist, Vector (@
    Decorator it = (Decorator) history.peek();
    it.set_travtaglist(dest);
  @)

  before -> Program, globalimports, GlobalImports (@
    Program it = (Program) history.peek();
    GlobalImports p = new GlobalImports();
    it.set_globalimports(p);
    history.push(p);
  @)

  after -> Program, globalimports, GlobalImports (@
    history.pop();
  @)

  before -> Program, cg, ClassGraph (@
    Program it = (Program) history.peek();
    ClassGraph p = new ClassGraph();
    it.set_cg(p);
    history.push(p);
  @)

  after -> Program, cg, ClassGraph (@
    history.pop();
  @)

  before -> GlobalImports, imports, Import_SList (@
    GlobalImports it = (GlobalImports) history.peek();
    Import_SList p = new Import_SList();
    it.set_imports(p);
    history.push(p);
  @)

  after -> GlobalImports, imports, Import_SList (@
    history.pop();
  @)

  before -> Import, packagename, PackageName (@
    Import it = (Import) history.peek();
    PackageName p = new PackageName();
    it.set_packagename(p);
    history.push(p);
  @)

  after -> Import, packagename, PackageName (@
    history.pop();
  @)

  before -> Import, importallclasses, ImportAllClasses (@
    Import it = (Import) history.peek();
    ImportAllClasses p = new ImportAllClasses();
    it.set_importallclasses(p);
    history.push(p);
  @)

  after -> Import, importallclasses, ImportAllClasses (@
    history.pop();
  @)

  before -> ClassGraph, defdict, Hashtable (@
    ClassGraph it = (ClassGraph) history.peek();
    it.set_defdict(dest);
  @)

  before -> ClassGraph, classes, ClassGraphEntry_DList (@
    ClassGraph it = (ClassGraph) history.peek();
    ClassGraphEntry_DList p = new ClassGraphEntry_DList();
    it.set_classes(p);
    history.push(p);
  @)

  after -> ClassGraph, classes, ClassGraphEntry_DList (@
    history.pop();
  @)

  before -> ClassGraph, tg, TraversalGraph (@
    ClassGraph it = (ClassGraph) history.peek();
    it.set_tg(dest);
  @)

  before -> ParseDirective, parsekeyword, ParseKeyword (@
    ParseDirective it = (ParseDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_parsekeyword((ParseKeyword) p);
    history.push(p);
  @)

  after -> ParseDirective, parsekeyword, ParseKeyword (@
    history.pop();
  @)

  before -> VisitorDirective, visitorkeyword, VisitorKeyword (@
    VisitorDirective it = (VisitorDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_visitorkeyword((VisitorKeyword) p);
    history.push(p);
  @)

  after -> VisitorDirective, visitorkeyword, VisitorKeyword (@
    history.pop();
  @)

  before -> PackageDirective, pkg, Package (@
    PackageDirective it = (PackageDirective) history.peek();
    Package p = new Package();
    it.set_pkg(p);
    history.push(p);
  @)

  after -> PackageDirective, pkg, Package (@
    history.pop();
  @)

  before -> PackageDirective, localimports, LocalImports (@
    PackageDirective it = (PackageDirective) history.peek();
    LocalImports p = new LocalImports();
    it.set_localimports(p);
    history.push(p);
  @)

  after -> PackageDirective, localimports, LocalImports (@
    history.pop();
  @)

  before -> Package, packagename, PackageName (@
    Package it = (Package) history.peek();
    PackageName p = new PackageName();
    it.set_packagename(p);
    history.push(p);
  @)

  after -> Package, packagename, PackageName (@
    history.pop();
  @)

  before -> LocalImports, imports, Import_SList (@
    LocalImports it = (LocalImports) history.peek();
    Import_SList p = new Import_SList();
    it.set_imports(p);
    history.push(p);
  @)

  after -> LocalImports, imports, Import_SList (@
    history.pop();
  @)

  before -> ClassDef, keywords, ClassKeyword_List (@
    ClassDef it = (ClassDef) history.peek();
    ClassKeyword_List p = new ClassKeyword_List();
    it.set_keywords(p);
    history.push(p);
  @)

  after -> ClassDef, keywords, ClassKeyword_List (@
    history.pop();
  @)

  before -> ClassDef, paramclassname, ParamClassName (@
    ClassDef it = (ClassDef) history.peek();
    ParamClassName p = new ParamClassName();
    it.set_paramclassname(p);
    history.push(p);
  @)

  after -> ClassDef, paramclassname, ParamClassName (@
    history.pop();
  @)

  before -> ClassDef, parsedirective, ParseDirective (@
    ClassDef it = (ClassDef) history.peek();
    ParseDirective p = new ParseDirective();
    it.set_parsedirective(p);
    history.push(p);
  @)

  after -> ClassDef, parsedirective, ParseDirective (@
    history.pop();
  @)

  before -> ClassDef, classparts, ClassParts (@
    ClassDef it = (ClassDef) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_classparts((ClassParts) p);
    history.push(p);
  @)

  after -> ClassDef, classparts, ClassParts (@
    history.pop();
  @)

  before -> ClassDef, classmethods, ClassMethods (@
    ClassDef it = (ClassDef) history.peek();
    ClassMethods p = new ClassMethods();
    it.set_classmethods(p);
    history.push(p);
  @)

  after -> ClassDef, classmethods, ClassMethods (@
    history.pop();
  @)

  before -> ClassDef, eoftoken, EOFtoken (@
    ClassDef it = (ClassDef) history.peek();
    EOFtoken p = new EOFtoken();
    it.set_eoftoken(p);
    history.push(p);
  @)

  after -> ClassDef, eoftoken, EOFtoken (@
    history.pop();
  @)

  before -> ParamClassName, classname, ClassName (@
    ParamClassName it = (ParamClassName) history.peek();
    ClassName p = new ClassName();
    it.set_classname(p);
    history.push(p);
  @)

  after -> ParamClassName, classname, ClassName (@
    history.pop();
  @)

  before -> ParamClassName, parameters, ClassName_Commalist (@
    ParamClassName it = (ParamClassName) history.peek();
    ClassName_Commalist p = new ClassName_Commalist();
    it.set_parameters(p);
    history.push(p);
  @)

  after -> ParamClassName, parameters, ClassName_Commalist (@
    history.pop();
  @)

  before -> ConstOrAltClass, parts, PartOrSyntax_List (@
    ConstOrAltClass it = (ConstOrAltClass) history.peek();
    PartOrSyntax_List p = new PartOrSyntax_List();
    it.set_parts(p);
    history.push(p);
  @)

  after -> ConstOrAltClass, parts, PartOrSyntax_List (@
    history.pop();
  @)

  before -> ConstOrAltClass, parents, ClassParents (@
    ConstOrAltClass it = (ConstOrAltClass) history.peek();
    ClassParents p = new ClassParents();
    it.set_parents(p);
    history.push(p);
  @)

  after -> ConstOrAltClass, parents, ClassParents (@
    history.pop();
  @)

  before -> Part, partname, PartName (@
    Part it = (Part) history.peek();
    PartName p = new PartName();
    it.set_partname(p);
    history.push(p);
  @)

  after -> Part, partname, PartName (@
    history.pop();
  @)

  before -> Part, keywords, PartKeyword_List (@
    Part it = (Part) history.peek();
    PartKeyword_List p = new PartKeyword_List();
    it.set_keywords(p);
    history.push(p);
  @)

  after -> Part, keywords, PartKeyword_List (@
    history.pop();
  @)

  before -> Part, classspec, ClassSpec (@
    Part it = (Part) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_classspec(p);
    history.push(p);
  @)

  after -> Part, classspec, ClassSpec (@
    history.pop();
  @)

  before -> Part, partinit, PartInit (@
    Part it = (Part) history.peek();
    PartInit p = new PartInit();
    it.set_partinit(p);
    history.push(p);
  @)

  after -> Part, partinit, PartInit (@
    history.pop();
  @)

  before -> PartInit, partinitkeyword, PartInitKeyword (@
    PartInit it = (PartInit) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_partinitkeyword((PartInitKeyword) p);
    history.push(p);
  @)

  after -> PartInit, partinitkeyword, PartInitKeyword (@
    history.pop();
  @)

  before -> PartInit, javacode, JavaCode (@
    PartInit it = (PartInit) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> PartInit, javacode, JavaCode (@
    history.pop();
  @)

  before -> OptionalPart, locallookahead, LocalLookahead (@
    OptionalPart it = (OptionalPart) history.peek();
    LocalLookahead p = new LocalLookahead();
    it.set_locallookahead(p);
    history.push(p);
  @)

  after -> OptionalPart, locallookahead, LocalLookahead (@
    history.pop();
  @)

  before -> OptionalPart, part, Part_Sandwich (@
    OptionalPart it = (OptionalPart) history.peek();
    Part_Sandwich p = new Part_Sandwich();
    it.set_part(p);
    history.push(p);
  @)

  after -> OptionalPart, part, Part_Sandwich (@
    history.pop();
  @)

  before -> ClassParents, superclasses, Superclasses (@
    ClassParents it = (ClassParents) history.peek();
    Superclasses p = new Superclasses();
    it.set_superclasses(p);
    history.push(p);
  @)

  after -> ClassParents, superclasses, Superclasses (@
    history.pop();
  @)

  before -> ClassParents, interfaces, Interfaces (@
    ClassParents it = (ClassParents) history.peek();
    Interfaces p = new Interfaces();
    it.set_interfaces(p);
    history.push(p);
  @)

  after -> ClassParents, interfaces, Interfaces (@
    history.pop();
  @)

  before -> Superclasses, extendskeyword, ExtendsKeyword (@
    Superclasses it = (Superclasses) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_extendskeyword((ExtendsKeyword) p);
    history.push(p);
  @)

  after -> Superclasses, extendskeyword, ExtendsKeyword (@
    history.pop();
  @)

  before -> Superclasses, superclasses, Superclass_Commalist (@
    Superclasses it = (Superclasses) history.peek();
    Superclass_Commalist p = new Superclass_Commalist();
    it.set_superclasses(p);
    history.push(p);
  @)

  after -> Superclasses, superclasses, Superclass_Commalist (@
    history.pop();
  @)

  before -> Superclass, classspec, ClassSpec (@
    Superclass it = (Superclass) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_classspec(p);
    history.push(p);
  @)

  after -> Superclass, classspec, ClassSpec (@
    history.pop();
  @)

  before -> Interfaces, implementskeyword, ImplementsKeyword (@
    Interfaces it = (Interfaces) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_implementskeyword((ImplementsKeyword) p);
    history.push(p);
  @)

  after -> Interfaces, implementskeyword, ImplementsKeyword (@
    history.pop();
  @)

  before -> Interfaces, interfaces, Interface_Commalist (@
    Interfaces it = (Interfaces) history.peek();
    Interface_Commalist p = new Interface_Commalist();
    it.set_interfaces(p);
    history.push(p);
  @)

  after -> Interfaces, interfaces, Interface_Commalist (@
    history.pop();
  @)

  before -> Interface, classspec, ClassSpec (@
    Interface it = (Interface) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_classspec(p);
    history.push(p);
  @)

  after -> Interface, classspec, ClassSpec (@
    history.pop();
  @)

  before -> AlternationClass, subclasses, Subclass_Barlist (@
    AlternationClass it = (AlternationClass) history.peek();
    Subclass_Barlist p = new Subclass_Barlist();
    it.set_subclasses(p);
    history.push(p);
  @)

  after -> AlternationClass, subclasses, Subclass_Barlist (@
    history.pop();
  @)

  before -> AlternationClass, commonkeyword, CommonKeyword (@
    AlternationClass it = (AlternationClass) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_commonkeyword((CommonKeyword) p);
    history.push(p);
  @)

  after -> AlternationClass, commonkeyword, CommonKeyword (@
    history.pop();
  @)

  before -> Subclass, locallookahead, LocalLookahead (@
    Subclass it = (Subclass) history.peek();
    LocalLookahead p = new LocalLookahead();
    it.set_locallookahead(p);
    history.push(p);
  @)

  after -> Subclass, locallookahead, LocalLookahead (@
    history.pop();
  @)

  before -> Subclass, classspec, ClassSpec (@
    Subclass it = (Subclass) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_classspec(p);
    history.push(p);
  @)

  after -> Subclass, classspec, ClassSpec (@
    history.pop();
  @)

  before -> LocalLookahead, lookaheadkeyword, LookaheadKeyword (@
    LocalLookahead it = (LocalLookahead) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_lookaheadkeyword((LookaheadKeyword) p);
    history.push(p);
  @)

  after -> LocalLookahead, lookaheadkeyword, LookaheadKeyword (@
    history.pop();
  @)

  before -> LocalLookahead, javacode, JavaCode (@
    LocalLookahead it = (LocalLookahead) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> LocalLookahead, javacode, JavaCode (@
    history.pop();
  @)

  before -> RepetitionClass, sandwiched, RepeatedPart_Sandwich (@
    RepetitionClass it = (RepetitionClass) history.peek();
    RepeatedPart_Sandwich p = new RepeatedPart_Sandwich();
    it.set_sandwiched(p);
    history.push(p);
  @)

  after -> RepetitionClass, sandwiched, RepeatedPart_Sandwich (@
    history.pop();
  @)

  before -> RepeatedPart, nonempty, ClassSpec (@
    RepeatedPart it = (RepeatedPart) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_nonempty(p);
    history.push(p);
  @)

  after -> RepeatedPart, nonempty, ClassSpec (@
    history.pop();
  @)

  before -> RepeatedPart, locallookahead, LocalLookahead (@
    RepeatedPart it = (RepeatedPart) history.peek();
    LocalLookahead p = new LocalLookahead();
    it.set_locallookahead(p);
    history.push(p);
  @)

  after -> RepeatedPart, locallookahead, LocalLookahead (@
    history.pop();
  @)

  before -> RepeatedPart, repeated, ClassSpec_Sandwich (@
    RepeatedPart it = (RepeatedPart) history.peek();
    ClassSpec_Sandwich p = new ClassSpec_Sandwich();
    it.set_repeated(p);
    history.push(p);
  @)

  after -> RepeatedPart, repeated, ClassSpec_Sandwich (@
    history.pop();
  @)

  before -> ClassSpec, classname, ClassName (@
    ClassSpec it = (ClassSpec) history.peek();
    ClassName p = new ClassName();
    it.set_classname(p);
    history.push(p);
  @)

  after -> ClassSpec, classname, ClassName (@
    history.pop();
  @)

  before -> ClassSpec, actual_parameters, ClassSpec_Commalist (@
    ClassSpec it = (ClassSpec) history.peek();
    ClassSpec_Commalist p = new ClassSpec_Commalist();
    it.set_actual_parameters(p);
    history.push(p);
  @)

  after -> ClassSpec, actual_parameters, ClassSpec_Commalist (@
    history.pop();
  @)

  before -> PlainSyntax, string, String (@
    PlainSyntax it = (PlainSyntax) history.peek();
    it.set_string(dest);
  @)

  before -> ProgramBehavior, behavior, Behavior_DList (@
    ProgramBehavior it = (ProgramBehavior) history.peek();
    Behavior_DList p = new Behavior_DList();
    it.set_behavior(p);
    history.push(p);
  @)

  after -> ProgramBehavior, behavior, Behavior_DList (@
    history.pop();
  @)

  before -> StrategyDefinition, strategyname, StrategyName (@
    StrategyDefinition it = (StrategyDefinition) history.peek();
    StrategyName p = new StrategyName();
    it.set_strategyname(p);
    history.push(p);
  @)

  after -> StrategyDefinition, strategyname, StrategyName (@
    history.pop();
  @)

  before -> StrategyDefinition, exp, StrategyExpression (@
    StrategyDefinition it = (StrategyDefinition) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_exp((StrategyExpression) p);
    history.push(p);
  @)

  after -> StrategyDefinition, exp, StrategyExpression (@
    history.pop();
  @)

  before -> StrategyGraph, edgeVec, Vector (@
    StrategyGraph it = (StrategyGraph) history.peek();
    it.set_edgeVec(dest);
  @)

  before -> StrategyGraph, edges, SGEdge_SList (@
    StrategyGraph it = (StrategyGraph) history.peek();
    SGEdge_SList p = new SGEdge_SList();
    it.set_edges(p);
    history.push(p);
  @)

  after -> StrategyGraph, edges, SGEdge_SList (@
    history.pop();
  @)

  before -> StrategyGraph, sources, ClassGlobSpec (@
    StrategyGraph it = (StrategyGraph) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_sources((ClassGlobSpec) p);
    history.push(p);
  @)

  after -> StrategyGraph, sources, ClassGlobSpec (@
    history.pop();
  @)

  before -> StrategyGraph, sourceEdges, Integer_NList (@
    StrategyGraph it = (StrategyGraph) history.peek();
    Integer_NList p = new Integer_NList();
    it.set_sourceEdges(p);
    history.push(p);
  @)

  after -> StrategyGraph, sourceEdges, Integer_NList (@
    history.pop();
  @)

  before -> StrategyGraph, targets, ClassGlobSpec (@
    StrategyGraph it = (StrategyGraph) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_targets((ClassGlobSpec) p);
    history.push(p);
  @)

  after -> StrategyGraph, targets, ClassGlobSpec (@
    history.pop();
  @)

  before -> SGEdge, source, ClassGlobSpec (@
    SGEdge it = (SGEdge) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_source((ClassGlobSpec) p);
    history.push(p);
  @)

  after -> SGEdge, source, ClassGlobSpec (@
    history.pop();
  @)

  before -> SGEdge, dest, ClassGlobSpec (@
    SGEdge it = (SGEdge) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_dest((ClassGlobSpec) p);
    history.push(p);
  @)

  after -> SGEdge, dest, ClassGlobSpec (@
    history.pop();
  @)

  before -> SGEdge, constraint, NegativeConstraint (@
    SGEdge it = (SGEdge) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_constraint((NegativeConstraint) p);
    history.push(p);
  @)

  after -> SGEdge, constraint, NegativeConstraint (@
    history.pop();
  @)

  before -> PathDirective, constraint, NegativeConstraint (@
    PathDirective it = (PathDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_constraint((NegativeConstraint) p);
    history.push(p);
  @)

  after -> PathDirective, constraint, NegativeConstraint (@
    history.pop();
  @)

  before -> PathDirective, segments, PathSegment_List (@
    PathDirective it = (PathDirective) history.peek();
    PathSegment_List p = new PathSegment_List();
    it.set_segments(p);
    history.push(p);
  @)

  after -> PathDirective, segments, PathSegment_List (@
    history.pop();
  @)

  before -> PathDirective, targetdirective, TargetDirective (@
    PathDirective it = (PathDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_targetdirective((TargetDirective) p);
    history.push(p);
  @)

  after -> PathDirective, targetdirective, TargetDirective (@
    history.pop();
  @)

  before -> PathSegment, node, PositiveConstraint (@
    PathSegment it = (PathSegment) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_node((PositiveConstraint) p);
    history.push(p);
  @)

  after -> PathSegment, node, PositiveConstraint (@
    history.pop();
  @)

  before -> PathSegment, constraint, NegativeConstraint (@
    PathSegment it = (PathSegment) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_constraint((NegativeConstraint) p);
    history.push(p);
  @)

  after -> PathSegment, constraint, NegativeConstraint (@
    history.pop();
  @)

  before -> Constraint, glob, GlobSpec (@
    Constraint it = (Constraint) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_glob((GlobSpec) p);
    history.push(p);
  @)

  after -> Constraint, glob, GlobSpec (@
    history.pop();
  @)

  before -> TargetDirective, targets, ClassGlobSpec (@
    TargetDirective it = (TargetDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_targets((ClassGlobSpec) p);
    history.push(p);
  @)

  after -> TargetDirective, targets, ClassGlobSpec (@
    history.pop();
  @)

  before -> StrategyVariable, strategyname, StrategyName (@
    StrategyVariable it = (StrategyVariable) history.peek();
    StrategyName p = new StrategyName();
    it.set_strategyname(p);
    history.push(p);
  @)

  after -> StrategyVariable, strategyname, StrategyName (@
    history.pop();
  @)

  before -> CompoundStrategy, args, StrategyExpression_Commalist (@
    CompoundStrategy it = (CompoundStrategy) history.peek();
    StrategyExpression_Commalist p = new StrategyExpression_Commalist();
    it.set_args(p);
    history.push(p);
  @)

  after -> CompoundStrategy, args, StrategyExpression_Commalist (@
    history.pop();
  @)

  before -> OneGlob, glob, Glob (@
    OneGlob it = (OneGlob) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_glob((Glob) p);
    history.push(p);
  @)

  after -> OneGlob, glob, Glob (@
    history.pop();
  @)

  before -> GlobSet, globs, Glob_Commalist (@
    GlobSet it = (GlobSet) history.peek();
    Glob_Commalist p = new Glob_Commalist();
    it.set_globs(p);
    history.push(p);
  @)

  after -> GlobSet, globs, Glob_Commalist (@
    history.pop();
  @)

  before -> ClassGlob, name, ClassNameGlob (@
    ClassGlob it = (ClassGlob) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_name((ClassNameGlob) p);
    history.push(p);
  @)

  after -> ClassGlob, name, ClassNameGlob (@
    history.pop();
  @)

  before -> PartGlob, source, SourceGlob (@
    PartGlob it = (PartGlob) history.peek();
    SourceGlob p = new SourceGlob();
    it.set_source(p);
    history.push(p);
  @)

  after -> PartGlob, source, SourceGlob (@
    history.pop();
  @)

  before -> PartGlob, name, PartNameGlob (@
    PartGlob it = (PartGlob) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_name((PartNameGlob) p);
    history.push(p);
  @)

  after -> PartGlob, name, PartNameGlob (@
    history.pop();
  @)

  before -> PartGlob, dest, DestGlob (@
    PartGlob it = (PartGlob) history.peek();
    DestGlob p = new DestGlob();
    it.set_dest(p);
    history.push(p);
  @)

  after -> PartGlob, dest, DestGlob (@
    history.pop();
  @)

  before -> SubclassGlob, source, SourceGlob (@
    SubclassGlob it = (SubclassGlob) history.peek();
    SourceGlob p = new SourceGlob();
    it.set_source(p);
    history.push(p);
  @)

  after -> SubclassGlob, source, SourceGlob (@
    history.pop();
  @)

  before -> SubclassGlob, dest, DestGlob (@
    SubclassGlob it = (SubclassGlob) history.peek();
    DestGlob p = new DestGlob();
    it.set_dest(p);
    history.push(p);
  @)

  after -> SubclassGlob, dest, DestGlob (@
    history.pop();
  @)

  before -> SuperclassGlob, source, SourceGlob (@
    SuperclassGlob it = (SuperclassGlob) history.peek();
    SourceGlob p = new SourceGlob();
    it.set_source(p);
    history.push(p);
  @)

  after -> SuperclassGlob, source, SourceGlob (@
    history.pop();
  @)

  before -> SuperclassGlob, dest, DestGlob (@
    SuperclassGlob it = (SuperclassGlob) history.peek();
    DestGlob p = new DestGlob();
    it.set_dest(p);
    history.push(p);
  @)

  after -> SuperclassGlob, dest, DestGlob (@
    history.pop();
  @)

  before -> SourceGlob, name, ClassNameGlob (@
    SourceGlob it = (SourceGlob) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_name((ClassNameGlob) p);
    history.push(p);
  @)

  after -> SourceGlob, name, ClassNameGlob (@
    history.pop();
  @)

  before -> DestGlob, name, ClassNameGlob (@
    DestGlob it = (DestGlob) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_name((ClassNameGlob) p);
    history.push(p);
  @)

  after -> DestGlob, name, ClassNameGlob (@
    history.pop();
  @)

  before -> ClassNameExact, classname, ClassName (@
    ClassNameExact it = (ClassNameExact) history.peek();
    ClassName p = new ClassName();
    it.set_classname(p);
    history.push(p);
  @)

  after -> ClassNameExact, classname, ClassName (@
    history.pop();
  @)

  before -> PartNameExact, partname, PartName (@
    PartNameExact it = (PartNameExact) history.peek();
    PartName p = new PartName();
    it.set_partname(p);
    history.push(p);
  @)

  after -> PartNameExact, partname, PartName (@
    history.pop();
  @)

  before -> OneClassGlob, classglob, ClassGlob (@
    OneClassGlob it = (OneClassGlob) history.peek();
    ClassGlob p = new ClassGlob();
    it.set_classglob(p);
    history.push(p);
  @)

  after -> OneClassGlob, classglob, ClassGlob (@
    history.pop();
  @)

  before -> ClassGlobSet, globs, ClassGlob_Commalist (@
    ClassGlobSet it = (ClassGlobSet) history.peek();
    ClassGlob_Commalist p = new ClassGlob_Commalist();
    it.set_globs(p);
    history.push(p);
  @)

  after -> ClassGlobSet, globs, ClassGlob_Commalist (@
    history.pop();
  @)

  before -> ClassBehavior, classes, ClassGlobSpec (@
    ClassBehavior it = (ClassBehavior) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_classes((ClassGlobSpec) p);
    history.push(p);
  @)

  after -> ClassBehavior, classes, ClassGlobSpec (@
    history.pop();
  @)

  before -> ClassBehavior, methods, ClassMethods (@
    ClassBehavior it = (ClassBehavior) history.peek();
    ClassMethods p = new ClassMethods();
    it.set_methods(p);
    history.push(p);
  @)

  after -> ClassBehavior, methods, ClassMethods (@
    history.pop();
  @)

  before -> ClassMethods, methods, Method_SList (@
    ClassMethods it = (ClassMethods) history.peek();
    Method_SList p = new Method_SList();
    it.set_methods(p);
    history.push(p);
  @)

  after -> ClassMethods, methods, Method_SList (@
    history.pop();
  @)

  before -> ClassMethods, wrapperdict, Hashtable (@
    ClassMethods it = (ClassMethods) history.peek();
    it.set_wrapperdict(dest);
  @)

  before -> HostSet, exactHosts, Hashtable (@
    HostSet it = (HostSet) history.peek();
    it.set_exactHosts(dest);
  @)

  before -> HostSet, partnames, Hashtable (@
    HostSet it = (HostSet) history.peek();
    it.set_partnames(dest);
  @)

  before -> HostSet, globs, GlobSet (@
    HostSet it = (HostSet) history.peek();
    GlobSet p = new GlobSet();
    it.set_globs(p);
    history.push(p);
  @)

  after -> HostSet, globs, GlobSet (@
    history.pop();
  @)

  before -> TraversalDef, name, TraversalName (@
    TraversalDef it = (TraversalDef) history.peek();
    TraversalName p = new TraversalName();
    it.set_name(p);
    history.push(p);
  @)

  after -> TraversalDef, name, TraversalName (@
    history.pop();
  @)

  before -> TraversalDef, parms, TraversalParms (@
    TraversalDef it = (TraversalDef) history.peek();
    TraversalParms p = new TraversalParms();
    it.set_parms(p);
    history.push(p);
  @)

  after -> TraversalDef, parms, TraversalParms (@
    history.pop();
  @)

  before -> TraversalDef, strat, StrategyExpression (@
    TraversalDef it = (TraversalDef) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_strat((StrategyExpression) p);
    history.push(p);
  @)

  after -> TraversalDef, strat, StrategyExpression (@
    history.pop();
  @)

  before -> TraversalParms, visitors, Visitor_Commalist (@
    TraversalParms it = (TraversalParms) history.peek();
    Visitor_Commalist p = new Visitor_Commalist();
    it.set_visitors(p);
    history.push(p);
  @)

  after -> TraversalParms, visitors, Visitor_Commalist (@
    history.pop();
  @)

  before -> Visitor, classname, ClassName (@
    Visitor it = (Visitor) history.peek();
    ClassName p = new ClassName();
    it.set_classname(p);
    history.push(p);
  @)

  after -> Visitor, classname, ClassName (@
    history.pop();
  @)

  before -> Visitor, visitorname, VisitorName (@
    Visitor it = (Visitor) history.peek();
    VisitorName p = new VisitorName();
    it.set_visitorname(p);
    history.push(p);
  @)

  after -> Visitor, visitorname, VisitorName (@
    history.pop();
  @)

  before -> MethodDef, methodsignature, MethodSignature (@
    MethodDef it = (MethodDef) history.peek();
    MethodSignature p = new MethodSignature();
    it.set_methodsignature(p);
    history.push(p);
  @)

  after -> MethodDef, methodsignature, MethodSignature (@
    history.pop();
  @)

  before -> MethodDef, methodbody, MethodBody (@
    MethodDef it = (MethodDef) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_methodbody((MethodBody) p);
    history.push(p);
  @)

  after -> MethodDef, methodbody, MethodBody (@
    history.pop();
  @)

  before -> MethodSignature, keywords, MethodKeyword_List (@
    MethodSignature it = (MethodSignature) history.peek();
    MethodKeyword_List p = new MethodKeyword_List();
    it.set_keywords(p);
    history.push(p);
  @)

  after -> MethodSignature, keywords, MethodKeyword_List (@
    history.pop();
  @)

  before -> MethodSignature, returnType, JavaType (@
    MethodSignature it = (MethodSignature) history.peek();
    JavaType p = new JavaType();
    it.set_returnType(p);
    history.push(p);
  @)

  after -> MethodSignature, returnType, JavaType (@
    history.pop();
  @)

  before -> MethodSignature, name, MethodName (@
    MethodSignature it = (MethodSignature) history.peek();
    MethodName p = new MethodName();
    it.set_name(p);
    history.push(p);
  @)

  after -> MethodSignature, name, MethodName (@
    history.pop();
  @)

  before -> MethodSignature, parms, MethodParm_Commalist (@
    MethodSignature it = (MethodSignature) history.peek();
    MethodParm_Commalist p = new MethodParm_Commalist();
    it.set_parms(p);
    history.push(p);
  @)

  after -> MethodSignature, parms, MethodParm_Commalist (@
    history.pop();
  @)

  before -> MethodSignature, throwsclause, Throws (@
    MethodSignature it = (MethodSignature) history.peek();
    Throws p = new Throws();
    it.set_throwsclause(p);
    history.push(p);
  @)

  after -> MethodSignature, throwsclause, Throws (@
    history.pop();
  @)

  before -> MethodParm, type, JavaType (@
    MethodParm it = (MethodParm) history.peek();
    JavaType p = new JavaType();
    it.set_type(p);
    history.push(p);
  @)

  after -> MethodParm, type, JavaType (@
    history.pop();
  @)

  before -> MethodParm, array1, ArraySpec_List (@
    MethodParm it = (MethodParm) history.peek();
    ArraySpec_List p = new ArraySpec_List();
    it.set_array1(p);
    history.push(p);
  @)

  after -> MethodParm, array1, ArraySpec_List (@
    history.pop();
  @)

  before -> MethodParm, name, ParmName (@
    MethodParm it = (MethodParm) history.peek();
    ParmName p = new ParmName();
    it.set_name(p);
    history.push(p);
  @)

  after -> MethodParm, name, ParmName (@
    history.pop();
  @)

  before -> MethodParm, array2, ArraySpec_List (@
    MethodParm it = (MethodParm) history.peek();
    ArraySpec_List p = new ArraySpec_List();
    it.set_array2(p);
    history.push(p);
  @)

  after -> MethodParm, array2, ArraySpec_List (@
    history.pop();
  @)

  before -> Throws, exceptions, ClassName_Commalist (@
    Throws it = (Throws) history.peek();
    ClassName_Commalist p = new ClassName_Commalist();
    it.set_exceptions(p);
    history.push(p);
  @)

  after -> Throws, exceptions, ClassName_Commalist (@
    history.pop();
  @)

  before -> VerbatimMethodBody, javacode, JavaCode (@
    VerbatimMethodBody it = (VerbatimMethodBody) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> VerbatimMethodBody, javacode, JavaCode (@
    history.pop();
  @)

  before -> AdaptiveMethodBody, trv, TraversalExpression (@
    AdaptiveMethodBody it = (AdaptiveMethodBody) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_trv((TraversalExpression) p);
    history.push(p);
  @)

  after -> AdaptiveMethodBody, trv, TraversalExpression (@
    history.pop();
  @)

  before -> AdaptiveMethodBody, vis, VisitorExpression (@
    AdaptiveMethodBody it = (AdaptiveMethodBody) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_vis((VisitorExpression) p);
    history.push(p);
  @)

  after -> AdaptiveMethodBody, vis, VisitorExpression (@
    history.pop();
  @)

  before -> TraversalRef, equals, Equals (@
    TraversalRef it = (TraversalRef) history.peek();
    Equals p = new Equals();
    it.set_equals(p);
    history.push(p);
  @)

  after -> TraversalRef, equals, Equals (@
    history.pop();
  @)

  before -> TraversalRef, name, TraversalName (@
    TraversalRef it = (TraversalRef) history.peek();
    TraversalName p = new TraversalName();
    it.set_name(p);
    history.push(p);
  @)

  after -> TraversalRef, name, TraversalName (@
    history.pop();
  @)

  before -> TraversalSpec, strat, StrategyExpression (@
    TraversalSpec it = (TraversalSpec) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_strat((StrategyExpression) p);
    history.push(p);
  @)

  after -> TraversalSpec, strat, StrategyExpression (@
    history.pop();
  @)

  before -> WithVisitorRef, visitorClasses, ClassName_Commalist (@
    WithVisitorRef it = (WithVisitorRef) history.peek();
    ClassName_Commalist p = new ClassName_Commalist();
    it.set_visitorClasses(p);
    history.push(p);
  @)

  after -> WithVisitorRef, visitorClasses, ClassName_Commalist (@
    history.pop();
  @)

  before -> ParenVisitorRef, visitorClasses, ClassName_Commalist (@
    ParenVisitorRef it = (ParenVisitorRef) history.peek();
    ClassName_Commalist p = new ClassName_Commalist();
    it.set_visitorClasses(p);
    history.push(p);
  @)

  after -> ParenVisitorRef, visitorClasses, ClassName_Commalist (@
    history.pop();
  @)

  before -> VisitorSpec, methods, ClassMethods (@
    VisitorSpec it = (VisitorSpec) history.peek();
    ClassMethods p = new ClassMethods();
    it.set_methods(p);
    history.push(p);
  @)

  after -> VisitorSpec, methods, ClassMethods (@
    history.pop();
  @)

  before -> Wrapper, kind, WrapperKind (@
    Wrapper it = (Wrapper) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_kind((WrapperKind) p);
    history.push(p);
  @)

  after -> Wrapper, kind, WrapperKind (@
    history.pop();
  @)

  before -> Wrapper, hosts, HostSpec (@
    Wrapper it = (Wrapper) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_hosts((HostSpec) p);
    history.push(p);
  @)

  after -> Wrapper, hosts, HostSpec (@
    history.pop();
  @)

  before -> Wrapper, javacode, JavaCode (@
    Wrapper it = (Wrapper) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> Wrapper, javacode, JavaCode (@
    history.pop();
  @)

  before -> Accessor, partname, PartName (@
    Accessor it = (Accessor) history.peek();
    PartName p = new PartName();
    it.set_partname(p);
    history.push(p);
  @)

  after -> Accessor, partname, PartName (@
    history.pop();
  @)

  before -> Accessor, javacode, JavaCode (@
    Accessor it = (Accessor) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> Accessor, javacode, JavaCode (@
    history.pop();
  @)

  before -> Constructor, javacode, JavaCode (@
    Constructor it = (Constructor) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> Constructor, javacode, JavaCode (@
    history.pop();
  @)

  before -> Start, javacode, JavaCode (@
    Start it = (Start) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> Start, javacode, JavaCode (@
    history.pop();
  @)

  before -> Finish, javacode, JavaCode (@
    Finish it = (Finish) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> Finish, javacode, JavaCode (@
    history.pop();
  @)

  before -> ReturnValue, type, JavaType (@
    ReturnValue it = (ReturnValue) history.peek();
    JavaType p = new JavaType();
    it.set_type(p);
    history.push(p);
  @)

  after -> ReturnValue, type, JavaType (@
    history.pop();
  @)

  before -> ReturnValue, exp, JavaCode (@
    ReturnValue it = (ReturnValue) history.peek();
    JavaCode p = new JavaCode();
    it.set_exp(p);
    history.push(p);
  @)

  after -> ReturnValue, exp, JavaCode (@
    history.pop();
  @)

  before -> Verbatim, javacode, JavaCode (@
    Verbatim it = (Verbatim) history.peek();
    JavaCode p = new JavaCode();
    it.set_javacode(p);
    history.push(p);
  @)

  after -> Verbatim, javacode, JavaCode (@
    history.pop();
  @)

  before -> PackageName, first, Nonempty_PackageName (@
    PackageName it = (PackageName) history.peek();
    Nonempty_PackageName p = new Nonempty_PackageName();
    it.set_first(p);
    history.push(p);
  @)

  after -> PackageName, first, Nonempty_PackageName (@
    history.pop();
  @)

  before -> ClassName, name, Name (@
    ClassName it = (ClassName) history.peek();
    Name p = new Name();
    it.set_name(p);
    history.push(p);
  @)

  after -> ClassName, name, Name (@
    history.pop();
  @)

  before -> PartName, name, IdentOrKeyword (@
    PartName it = (PartName) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_name((IdentOrKeyword) p);
    history.push(p);
  @)

  after -> PartName, name, IdentOrKeyword (@
    history.pop();
  @)

  before -> TraversalName, name, Name (@
    TraversalName it = (TraversalName) history.peek();
    Name p = new Name();
    it.set_name(p);
    history.push(p);
  @)

  after -> TraversalName, name, Name (@
    history.pop();
  @)

  before -> VisitorName, name, Name (@
    VisitorName it = (VisitorName) history.peek();
    Name p = new Name();
    it.set_name(p);
    history.push(p);
  @)

  after -> VisitorName, name, Name (@
    history.pop();
  @)

  before -> MethodName, name, Ident (@
    MethodName it = (MethodName) history.peek();
    it.set_name(dest);
  @)

  before -> ParmName, name, Ident (@
    ParmName it = (ParmName) history.peek();
    it.set_name(dest);
  @)

  before -> StrategyName, name, Ident (@
    StrategyName it = (StrategyName) history.peek();
    it.set_name(dest);
  @)

  before -> JavaType, type, Name (@
    JavaType it = (JavaType) history.peek();
    Name p = new Name();
    it.set_type(p);
    history.push(p);
  @)

  after -> JavaType, type, Name (@
    history.pop();
  @)

  before -> JavaCode, code, Text (@
    JavaCode it = (JavaCode) history.peek();
    it.set_code(dest);
  @)

  before -> Name, first, Nonempty_Name (@
    Name it = (Name) history.peek();
    Nonempty_Name p = new Nonempty_Name();
    it.set_first(p);
    history.push(p);
  @)

  after -> Name, first, Nonempty_Name (@
    history.pop();
  @)

  before -> OtherIdent, id, Ident (@
    OtherIdent it = (OtherIdent) history.peek();
    it.set_id(dest);
  @)

  before -> TraversalMethodName, methodname, MethodName (@
    TraversalMethodName it = (TraversalMethodName) history.peek();
    MethodName p = new MethodName();
    it.set_methodname(p);
    history.push(p);
  @)

  after -> TraversalMethodName, methodname, MethodName (@
    history.pop();
  @)

  before -> ClassType, is_con, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_con(dest);
  @)

  before -> ClassType, is_alt, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_alt(dest);
  @)

  before -> ClassType, is_rep, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_rep(dest);
  @)

  before -> ClassType, is_public, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_public(dest);
  @)

  before -> ClassType, is_final, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_final(dest);
  @)

  before -> ClassType, is_interface, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_interface(dest);
  @)

  before -> ClassType, is_not_parsed, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_not_parsed(dest);
  @)

  before -> ClassType, is_visitor, boolean (@
    ClassType it = (ClassType) history.peek();
    it.set_is_visitor(dest);
  @)

  before -> PartType, is_final, boolean (@
    PartType it = (PartType) history.peek();
    it.set_is_final(dest);
  @)

  before -> PartType, is_static, boolean (@
    PartType it = (PartType) history.peek();
    it.set_is_static(dest);
  @)

  before -> PartType, is_derived, boolean (@
    PartType it = (PartType) history.peek();
    it.set_is_derived(dest);
  @)

  before -> PartType, has_getter, boolean (@
    PartType it = (PartType) history.peek();
    it.set_has_getter(dest);
  @)

  before -> PartType, has_setter, boolean (@
    PartType it = (PartType) history.peek();
    it.set_has_setter(dest);
  @)

  before -> Parts, first, Nonempty_Parts (@
    Parts it = (Parts) history.peek();
    Nonempty_Parts p = new Nonempty_Parts();
    it.set_first(p);
    history.push(p);
  @)

  after -> Parts, first, Nonempty_Parts (@
    history.pop();
  @)

  before -> PlacementVisitor, ugraph, UGraph (@
    PlacementVisitor it = (PlacementVisitor) history.peek();
    UGraph p = new UGraph();
    it.set_ugraph(p);
    history.push(p);
  @)

  after -> PlacementVisitor, ugraph, UGraph (@
    history.pop();
  @)

  before -> EdgeDistinctionVisitor, edgetype, String (@
    EdgeDistinctionVisitor it = (EdgeDistinctionVisitor) history.peek();
    it.set_edgetype(dest);
  @)

  before -> ClassNameRetVisitor, cn, ClassName (@
    ClassNameRetVisitor it = (ClassNameRetVisitor) history.peek();
    ClassName p = new ClassName();
    it.set_cn(p);
    history.push(p);
  @)

  after -> ClassNameRetVisitor, cn, ClassName (@
    history.pop();
  @)

  before -> ClassNameTranspVisitor, pcn, ParamClassName (@
    ClassNameTranspVisitor it = (ClassNameTranspVisitor) history.peek();
    ParamClassName p = new ParamClassName();
    it.set_pcn(p);
    history.push(p);
  @)

  after -> ClassNameTranspVisitor, pcn, ParamClassName (@
    history.pop();
  @)

  before -> EdgeVisitor, edv, EdgeDistinctionVisitor (@
    EdgeVisitor it = (EdgeVisitor) history.peek();
    EdgeDistinctionVisitor p = new EdgeDistinctionVisitor();
    it.set_edv(p);
    history.push(p);
  @)

  after -> EdgeVisitor, edv, EdgeDistinctionVisitor (@
    history.pop();
  @)

  before -> EdgeVisitor, cntv, ClassNameTranspVisitor (@
    EdgeVisitor it = (EdgeVisitor) history.peek();
    ClassNameTranspVisitor p = new ClassNameTranspVisitor();
    it.set_cntv(p);
    history.push(p);
  @)

  after -> EdgeVisitor, cntv, ClassNameTranspVisitor (@
    history.pop();
  @)

  before -> EdgeVisitor, ugraph, UGraph (@
    EdgeVisitor it = (EdgeVisitor) history.peek();
    UGraph p = new UGraph();
    it.set_ugraph(p);
    history.push(p);
  @)

  after -> EdgeVisitor, ugraph, UGraph (@
    history.pop();
  @)

  before -> VertexReadingVisitor, thegraph, UGraph (@
    VertexReadingVisitor it = (VertexReadingVisitor) history.peek();
    UGraph p = new UGraph();
    it.set_thegraph(p);
    history.push(p);
  @)

  after -> VertexReadingVisitor, thegraph, UGraph (@
    history.pop();
  @)

  before -> VertexReadingVisitor, graphstring, String (@
    VertexReadingVisitor it = (VertexReadingVisitor) history.peek();
    it.set_graphstring(dest);
  @)

  before -> VertexReadingVisitor, lookupvid, Integer (@
    VertexReadingVisitor it = (VertexReadingVisitor) history.peek();
    it.set_lookupvid(dest);
  @)

  before -> VertexReadingVisitor, uppervalue, Integer (@
    VertexReadingVisitor it = (VertexReadingVisitor) history.peek();
    it.set_uppervalue(dest);
  @)

  before -> EdgeReadingVisitor, thegraph, UGraph (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    UGraph p = new UGraph();
    it.set_thegraph(p);
    history.push(p);
  @)

  after -> EdgeReadingVisitor, thegraph, UGraph (@
    history.pop();
  @)

  before -> EdgeReadingVisitor, graphstring, String (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    it.set_graphstring(dest);
  @)

  before -> EdgeReadingVisitor, commonstring, String (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    it.set_commonstring(dest);
  @)

  before -> EdgeReadingVisitor, lookupvid, Integer (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    it.set_lookupvid(dest);
  @)

  before -> EdgeReadingVisitor, fromtype, String (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    it.set_fromtype(dest);
  @)

  before -> EdgeReadingVisitor, pipeswitch, Integer (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    it.set_pipeswitch(dest);
  @)

  before -> EdgeReadingVisitor, listswitch, Integer (@
    EdgeReadingVisitor it = (EdgeReadingVisitor) history.peek();
    it.set_listswitch(dest);
  @)

  before -> ReadVertexVisitor, elements, VertexContainer (@
    ReadVertexVisitor it = (ReadVertexVisitor) history.peek();
    VertexContainer p = new VertexContainer();
    it.set_elements(p);
    history.push(p);
  @)

  after -> ReadVertexVisitor, elements, VertexContainer (@
    history.pop();
  @)

  before -> VertexContainer, construction, Vector (@
    VertexContainer it = (VertexContainer) history.peek();
    it.set_construction(dest);
  @)

  before -> VertexContainer, alternation, Vector (@
    VertexContainer it = (VertexContainer) history.peek();
    it.set_alternation(dest);
  @)

  before -> VertexContainer, termination, Vector (@
    VertexContainer it = (VertexContainer) history.peek();
    it.set_termination(dest);
  @)

  before -> ReadEdgeVisitor, elements, EdgeContainer (@
    ReadEdgeVisitor it = (ReadEdgeVisitor) history.peek();
    EdgeContainer p = new EdgeContainer();
    it.set_elements(p);
    history.push(p);
  @)

  after -> ReadEdgeVisitor, elements, EdgeContainer (@
    history.pop();
  @)

  before -> EdgeContainer, construction, Vector (@
    EdgeContainer it = (EdgeContainer) history.peek();
    it.set_construction(dest);
  @)

  before -> EdgeContainer, alternation, Vector (@
    EdgeContainer it = (EdgeContainer) history.peek();
    it.set_alternation(dest);
  @)

  before -> CountingVisitor, total, Integer (@
    CountingVisitor it = (CountingVisitor) history.peek();
    it.set_total(dest);
  @)

  before -> ListVectorVisitor, sv, Vector (@
    ListVectorVisitor it = (ListVectorVisitor) history.peek();
    it.set_sv(dest);
  @)

  before -> ListVectorVisitor, dv, Vector (@
    ListVectorVisitor it = (ListVectorVisitor) history.peek();
    it.set_dv(dest);
  @)

  before -> ListVectorVisitor, bv, Vector (@
    ListVectorVisitor it = (ListVectorVisitor) history.peek();
    it.set_bv(dest);
  @)

  before -> DecoCollectVisitor, duid, UID (@
    DecoCollectVisitor it = (DecoCollectVisitor) history.peek();
    UID p = new UID();
    it.set_duid(p);
    history.push(p);
  @)

  after -> DecoCollectVisitor, duid, UID (@
    history.pop();
  @)

  before -> DecoCollectVisitor, v, Vector (@
    DecoCollectVisitor it = (DecoCollectVisitor) history.peek();
    it.set_v(dest);
  @)

  before -> RepClassSpecVisitor, first, Name (@
    RepClassSpecVisitor it = (RepClassSpecVisitor) history.peek();
    Name p = new Name();
    it.set_first(p);
    history.push(p);
  @)

  after -> RepClassSpecVisitor, first, Name (@
    history.pop();
  @)

  before -> RepClassSpecVisitor, inner, Name (@
    RepClassSpecVisitor it = (RepClassSpecVisitor) history.peek();
    Name p = new Name();
    it.set_inner(p);
    history.push(p);
  @)

  after -> RepClassSpecVisitor, inner, Name (@
    history.pop();
  @)

  before -> PlaceVertexVisitor, pos, Coordinates (@
    PlaceVertexVisitor it = (PlaceVertexVisitor) history.peek();
    Coordinates p = new Coordinates();
    it.set_pos(p);
    history.push(p);
  @)

  after -> PlaceVertexVisitor, pos, Coordinates (@
    history.pop();
  @)

  before -> PlaceVertexVisitor, vtable, Hashtable (@
    PlaceVertexVisitor it = (PlaceVertexVisitor) history.peek();
    it.set_vtable(dest);
  @)

  before -> PlaceVertexVisitor, etable, Hashtable (@
    PlaceVertexVisitor it = (PlaceVertexVisitor) history.peek();
    it.set_etable(dest);
  @)

  before -> SomeClassSpecVisitor, uce, UConstEdge (@
    SomeClassSpecVisitor it = (SomeClassSpecVisitor) history.peek();
    UConstEdge p = new UConstEdge();
    it.set_uce(p);
    history.push(p);
  @)

  after -> SomeClassSpecVisitor, uce, UConstEdge (@
    history.pop();
  @)

  before -> IntModVisitor, il, InterfaceModifier_List (@
    IntModVisitor it = (IntModVisitor) history.peek();
    InterfaceModifier_List p = new InterfaceModifier_List();
    it.set_il(p);
    history.push(p);
  @)

  after -> IntModVisitor, il, InterfaceModifier_List (@
    history.pop();
  @)

  before -> ClassModVisitor, sl, ScopeIdentifier_List (@
    ClassModVisitor it = (ClassModVisitor) history.peek();
    ScopeIdentifier_List p = new ScopeIdentifier_List();
    it.set_sl(p);
    history.push(p);
  @)

  after -> ClassModVisitor, sl, ScopeIdentifier_List (@
    history.pop();
  @)

  before -> PartModVisitor, pl, PartModifier_List (@
    PartModVisitor it = (PartModVisitor) history.peek();
    PartModifier_List p = new PartModifier_List();
    it.set_pl(p);
    history.push(p);
  @)

  after -> PartModVisitor, pl, PartModifier_List (@
    history.pop();
  @)

  before -> cdStringVisitor, return_val, String (@
    cdStringVisitor it = (cdStringVisitor) history.peek();
    it.set_return_val(dest);
  @)

  before -> ConstVisitor, vtable, Hashtable (@
    ConstVisitor it = (ConstVisitor) history.peek();
    it.set_vtable(dest);
  @)

  before -> ConstVisitor, etable, Hashtable (@
    ConstVisitor it = (ConstVisitor) history.peek();
    it.set_etable(dest);
  @)

  before -> AltVisitor, vtable, Hashtable (@
    AltVisitor it = (AltVisitor) history.peek();
    it.set_vtable(dest);
  @)

  before -> AltVisitor, etable, Hashtable (@
    AltVisitor it = (AltVisitor) history.peek();
    it.set_etable(dest);
  @)

  before -> IntVisitor, vtable, Hashtable (@
    IntVisitor it = (IntVisitor) history.peek();
    it.set_vtable(dest);
  @)

  before -> IntVisitor, etable, Hashtable (@
    IntVisitor it = (IntVisitor) history.peek();
    it.set_etable(dest);
  @)

  before -> SourceEdgeCollector, sg, StrategyGraph (@
    SourceEdgeCollector it = (SourceEdgeCollector) history.peek();
    StrategyGraph p = new StrategyGraph();
    it.set_sg(p);
    history.push(p);
  @)

  after -> SourceEdgeCollector, sg, StrategyGraph (@
    history.pop();
  @)

  before -> SourceEdgeCollector, edges, Integer_NList (@
    SourceEdgeCollector it = (SourceEdgeCollector) history.peek();
    Integer_NList p = new Integer_NList();
    it.set_edges(p);
    history.push(p);
  @)

  after -> SourceEdgeCollector, edges, Integer_NList (@
    history.pop();
  @)

  before -> GlobMatcher, glob, Glob (@
    GlobMatcher it = (GlobMatcher) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_glob((Glob) p);
    history.push(p);
  @)

  after -> GlobMatcher, glob, Glob (@
    history.pop();
  @)

  before -> GlobMatcher, found_one, boolean (@
    GlobMatcher it = (GlobMatcher) history.peek();
    it.set_found_one(dest);
  @)

  before -> GlobCollector, spec, GlobSet (@
    GlobCollector it = (GlobCollector) history.peek();
    GlobSet p = new GlobSet();
    it.set_spec(p);
    history.push(p);
  @)

  after -> GlobCollector, spec, GlobSet (@
    history.pop();
  @)

  before -> ClassGlobCollector, spec, ClassGlobSet (@
    ClassGlobCollector it = (ClassGlobCollector) history.peek();
    ClassGlobSet p = new ClassGlobSet();
    it.set_spec(p);
    history.push(p);
  @)

  after -> ClassGlobCollector, spec, ClassGlobSet (@
    history.pop();
  @)

  before -> EdgeGlobCollector, spec, GlobSet (@
    EdgeGlobCollector it = (EdgeGlobCollector) history.peek();
    GlobSet p = new GlobSet();
    it.set_spec(p);
    history.push(p);
  @)

  after -> EdgeGlobCollector, spec, GlobSet (@
    history.pop();
  @)

  before -> OutgoingEdgeSpecConvertor, spec, GlobSet (@
    OutgoingEdgeSpecConvertor it = (OutgoingEdgeSpecConvertor) history.peek();
    GlobSet p = new GlobSet();
    it.set_spec(p);
    history.push(p);
  @)

  after -> OutgoingEdgeSpecConvertor, spec, GlobSet (@
    history.pop();
  @)

  before -> SGEdgeMatcher, c, ClassNameI (@
    SGEdgeMatcher it = (SGEdgeMatcher) history.peek();
    it.set_c(dest);
  @)

  before -> SGEdgeMatcher, index, int (@
    SGEdgeMatcher it = (SGEdgeMatcher) history.peek();
    it.set_index(dest);
  @)

  before -> SGEdgeMatcher, return_val, Vector (@
    SGEdgeMatcher it = (SGEdgeMatcher) history.peek();
    it.set_return_val(dest);
  @)

  before -> TGVertexCollector, tg, TraversalGraph (@
    TGVertexCollector it = (TGVertexCollector) history.peek();
    it.set_tg(dest);
  @)

  before -> TGEdgeGlobMaker, s, ClassName (@
    TGEdgeGlobMaker it = (TGEdgeGlobMaker) history.peek();
    ClassName p = new ClassName();
    it.set_s(p);
    history.push(p);
  @)

  after -> TGEdgeGlobMaker, s, ClassName (@
    history.pop();
  @)

  before -> TGEdgeGlobMaker, d, ClassName (@
    TGEdgeGlobMaker it = (TGEdgeGlobMaker) history.peek();
    ClassName p = new ClassName();
    it.set_d(p);
    history.push(p);
  @)

  after -> TGEdgeGlobMaker, d, ClassName (@
    history.pop();
  @)

  before -> TGEdgeGlobMaker, cl, ClassName (@
    TGEdgeGlobMaker it = (TGEdgeGlobMaker) history.peek();
    ClassName p = new ClassName();
    it.set_cl(p);
    history.push(p);
  @)

  after -> TGEdgeGlobMaker, cl, ClassName (@
    history.pop();
  @)

  before -> TGEdgeGlobMaker, name, PartName (@
    TGEdgeGlobMaker it = (TGEdgeGlobMaker) history.peek();
    PartName p = new PartName();
    it.set_name(p);
    history.push(p);
  @)

  after -> TGEdgeGlobMaker, name, PartName (@
    history.pop();
  @)

  before -> TGEdgeGlobMaker, return_val, Glob (@
    TGEdgeGlobMaker it = (TGEdgeGlobMaker) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_return_val((Glob) p);
    history.push(p);
  @)

  after -> TGEdgeGlobMaker, return_val, Glob (@
    history.pop();
  @)

  before -> TGCreateVisitor, g, TraversalGraph (@
    TGCreateVisitor it = (TGCreateVisitor) history.peek();
    it.set_g(dest);
  @)

  before -> TGCreateVisitor, vtable, Hashtable (@
    TGCreateVisitor it = (TGCreateVisitor) history.peek();
    it.set_vtable(dest);
  @)

  before -> SaveGraphVisitor, graphString, String (@
    SaveGraphVisitor it = (SaveGraphVisitor) history.peek();
    it.set_graphString(dest);
  @)

  before -> SelectMarkedVisitor, bflag, boolean (@
    SelectMarkedVisitor it = (SelectMarkedVisitor) history.peek();
    it.set_bflag(dest);
  @)

  before -> SelectMarkedVisitor, cflag, boolean (@
    SelectMarkedVisitor it = (SelectMarkedVisitor) history.peek();
    it.set_cflag(dest);
  @)

  before -> SelectMarkedVisitor, anyEdgeflag, boolean (@
    SelectMarkedVisitor it = (SelectMarkedVisitor) history.peek();
    it.set_anyEdgeflag(dest);
  @)

  before -> SelectMarkedVisitor, graphString, String (@
    SelectMarkedVisitor it = (SelectMarkedVisitor) history.peek();
    it.set_graphString(dest);
  @)

  before -> SelectMarkedVisitor, ioeString, String (@
    SelectMarkedVisitor it = (SelectMarkedVisitor) history.peek();
    it.set_ioeString(dest);
  @)

  before -> SGraphCollector, names, Vector (@
    SGraphCollector it = (SGraphCollector) history.peek();
    it.set_names(dest);
  @)

  before -> SGraphCollector, graphs, Vector (@
    SGraphCollector it = (SGraphCollector) history.peek();
    it.set_graphs(dest);
  @)

  before -> VecVisitor, names, Vector (@
    VecVisitor it = (VecVisitor) history.peek();
    it.set_names(dest);
  @)

  before -> StringVisitor, name, String (@
    StringVisitor it = (StringVisitor) history.peek();
    it.set_name(dest);
  @)

  before -> PrintVisitor, indent, int (@
    PrintVisitor it = (PrintVisitor) history.peek();
    it.set_indent(dest);
  @)

  before -> PrintVisitor, needSpace, boolean (@
    PrintVisitor it = (PrintVisitor) history.peek();
    it.set_needSpace(dest);
  @)

  before -> EqualVisitor, is_equal, boolean (@
    EqualVisitor it = (EqualVisitor) history.peek();
    it.set_is_equal(dest);
  @)

  before -> DisplayVisitor, indent, int (@
    DisplayVisitor it = (DisplayVisitor) history.peek();
    it.set_indent(dest);
  @)

  before -> TraceVisitor, indent, int (@
    TraceVisitor it = (TraceVisitor) history.peek();
    it.set_indent(dest);
  @)

  before -> Import_SList, first, Nonempty_Import_SList (@
    Import_SList it = (Import_SList) history.peek();
    Nonempty_Import_SList p = new Nonempty_Import_SList();
    it.set_first(p);
    history.push(p);
  @)

  after -> Import_SList, first, Nonempty_Import_SList (@
    history.pop();
  @)

  before -> ClassGraphEntry_DList, first, Nonempty_ClassGraphEntry_DList (@
    ClassGraphEntry_DList it = (ClassGraphEntry_DList) history.peek();
    Nonempty_ClassGraphEntry_DList p = new Nonempty_ClassGraphEntry_DList();
    it.set_first(p);
    history.push(p);
  @)

  after -> ClassGraphEntry_DList, first, Nonempty_ClassGraphEntry_DList (@
    history.pop();
  @)

  before -> ClassKeyword_List, first, Nonempty_ClassKeyword_List (@
    ClassKeyword_List it = (ClassKeyword_List) history.peek();
    Nonempty_ClassKeyword_List p = new Nonempty_ClassKeyword_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> ClassKeyword_List, first, Nonempty_ClassKeyword_List (@
    history.pop();
  @)

  before -> ClassName_Commalist, first, Nonempty_ClassName_Commalist (@
    ClassName_Commalist it = (ClassName_Commalist) history.peek();
    Nonempty_ClassName_Commalist p = new Nonempty_ClassName_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> ClassName_Commalist, first, Nonempty_ClassName_Commalist (@
    history.pop();
  @)

  before -> PartOrSyntax_List, first, Nonempty_PartOrSyntax_List (@
    PartOrSyntax_List it = (PartOrSyntax_List) history.peek();
    Nonempty_PartOrSyntax_List p = new Nonempty_PartOrSyntax_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> PartOrSyntax_List, first, Nonempty_PartOrSyntax_List (@
    history.pop();
  @)

  before -> PartKeyword_List, first, Nonempty_PartKeyword_List (@
    PartKeyword_List it = (PartKeyword_List) history.peek();
    Nonempty_PartKeyword_List p = new Nonempty_PartKeyword_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> PartKeyword_List, first, Nonempty_PartKeyword_List (@
    history.pop();
  @)

  before -> Part_Sandwich, first, Syntax_List (@
    Part_Sandwich it = (Part_Sandwich) history.peek();
    Syntax_List p = new Syntax_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> Part_Sandwich, first, Syntax_List (@
    history.pop();
  @)

  before -> Part_Sandwich, inner, Part (@
    Part_Sandwich it = (Part_Sandwich) history.peek();
    Part p = new Part();
    it.set_inner(p);
    history.push(p);
  @)

  after -> Part_Sandwich, inner, Part (@
    history.pop();
  @)

  before -> Part_Sandwich, second, Syntax_List (@
    Part_Sandwich it = (Part_Sandwich) history.peek();
    Syntax_List p = new Syntax_List();
    it.set_second(p);
    history.push(p);
  @)

  after -> Part_Sandwich, second, Syntax_List (@
    history.pop();
  @)

  before -> Superclass_Commalist, first, Nonempty_Superclass_Commalist (@
    Superclass_Commalist it = (Superclass_Commalist) history.peek();
    Nonempty_Superclass_Commalist p = new Nonempty_Superclass_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> Superclass_Commalist, first, Nonempty_Superclass_Commalist (@
    history.pop();
  @)

  before -> Interface_Commalist, first, Nonempty_Interface_Commalist (@
    Interface_Commalist it = (Interface_Commalist) history.peek();
    Nonempty_Interface_Commalist p = new Nonempty_Interface_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> Interface_Commalist, first, Nonempty_Interface_Commalist (@
    history.pop();
  @)

  before -> Subclass_Barlist, first, Nonempty_Subclass_Barlist (@
    Subclass_Barlist it = (Subclass_Barlist) history.peek();
    Nonempty_Subclass_Barlist p = new Nonempty_Subclass_Barlist();
    it.set_first(p);
    history.push(p);
  @)

  after -> Subclass_Barlist, first, Nonempty_Subclass_Barlist (@
    history.pop();
  @)

  before -> RepeatedPart_Sandwich, first, Syntax_List (@
    RepeatedPart_Sandwich it = (RepeatedPart_Sandwich) history.peek();
    Syntax_List p = new Syntax_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> RepeatedPart_Sandwich, first, Syntax_List (@
    history.pop();
  @)

  before -> RepeatedPart_Sandwich, inner, RepeatedPart (@
    RepeatedPart_Sandwich it = (RepeatedPart_Sandwich) history.peek();
    RepeatedPart p = new RepeatedPart();
    it.set_inner(p);
    history.push(p);
  @)

  after -> RepeatedPart_Sandwich, inner, RepeatedPart (@
    history.pop();
  @)

  before -> RepeatedPart_Sandwich, second, Syntax_List (@
    RepeatedPart_Sandwich it = (RepeatedPart_Sandwich) history.peek();
    Syntax_List p = new Syntax_List();
    it.set_second(p);
    history.push(p);
  @)

  after -> RepeatedPart_Sandwich, second, Syntax_List (@
    history.pop();
  @)

  before -> ClassSpec_Sandwich, first, Syntax_List (@
    ClassSpec_Sandwich it = (ClassSpec_Sandwich) history.peek();
    Syntax_List p = new Syntax_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> ClassSpec_Sandwich, first, Syntax_List (@
    history.pop();
  @)

  before -> ClassSpec_Sandwich, inner, ClassSpec (@
    ClassSpec_Sandwich it = (ClassSpec_Sandwich) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_inner(p);
    history.push(p);
  @)

  after -> ClassSpec_Sandwich, inner, ClassSpec (@
    history.pop();
  @)

  before -> ClassSpec_Sandwich, second, Syntax_List (@
    ClassSpec_Sandwich it = (ClassSpec_Sandwich) history.peek();
    Syntax_List p = new Syntax_List();
    it.set_second(p);
    history.push(p);
  @)

  after -> ClassSpec_Sandwich, second, Syntax_List (@
    history.pop();
  @)

  before -> Syntax_List, first, Nonempty_Syntax_List (@
    Syntax_List it = (Syntax_List) history.peek();
    Nonempty_Syntax_List p = new Nonempty_Syntax_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> Syntax_List, first, Nonempty_Syntax_List (@
    history.pop();
  @)

  before -> ClassSpec_Commalist, first, Nonempty_ClassSpec_Commalist (@
    ClassSpec_Commalist it = (ClassSpec_Commalist) history.peek();
    Nonempty_ClassSpec_Commalist p = new Nonempty_ClassSpec_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> ClassSpec_Commalist, first, Nonempty_ClassSpec_Commalist (@
    history.pop();
  @)

  before -> Behavior_DList, first, Nonempty_Behavior_DList (@
    Behavior_DList it = (Behavior_DList) history.peek();
    Nonempty_Behavior_DList p = new Nonempty_Behavior_DList();
    it.set_first(p);
    history.push(p);
  @)

  after -> Behavior_DList, first, Nonempty_Behavior_DList (@
    history.pop();
  @)

  before -> SGEdge_SList, first, Nonempty_SGEdge_SList (@
    SGEdge_SList it = (SGEdge_SList) history.peek();
    Nonempty_SGEdge_SList p = new Nonempty_SGEdge_SList();
    it.set_first(p);
    history.push(p);
  @)

  after -> SGEdge_SList, first, Nonempty_SGEdge_SList (@
    history.pop();
  @)

  before -> Integer_NList, first, Nonempty_Integer_NList (@
    Integer_NList it = (Integer_NList) history.peek();
    Nonempty_Integer_NList p = new Nonempty_Integer_NList();
    it.set_first(p);
    history.push(p);
  @)

  after -> Integer_NList, first, Nonempty_Integer_NList (@
    history.pop();
  @)

  before -> PathSegment_List, first, Nonempty_PathSegment_List (@
    PathSegment_List it = (PathSegment_List) history.peek();
    Nonempty_PathSegment_List p = new Nonempty_PathSegment_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> PathSegment_List, first, Nonempty_PathSegment_List (@
    history.pop();
  @)

  before -> StrategyExpression_Commalist, first, Nonempty_StrategyExpression_Commalist (@
    StrategyExpression_Commalist it = (StrategyExpression_Commalist) history.peek();
    Nonempty_StrategyExpression_Commalist p = new Nonempty_StrategyExpression_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> StrategyExpression_Commalist, first, Nonempty_StrategyExpression_Commalist (@
    history.pop();
  @)

  before -> Glob_Commalist, first, Nonempty_Glob_Commalist (@
    Glob_Commalist it = (Glob_Commalist) history.peek();
    Nonempty_Glob_Commalist p = new Nonempty_Glob_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> Glob_Commalist, first, Nonempty_Glob_Commalist (@
    history.pop();
  @)

  before -> ClassGlob_Commalist, first, Nonempty_ClassGlob_Commalist (@
    ClassGlob_Commalist it = (ClassGlob_Commalist) history.peek();
    Nonempty_ClassGlob_Commalist p = new Nonempty_ClassGlob_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> ClassGlob_Commalist, first, Nonempty_ClassGlob_Commalist (@
    history.pop();
  @)

  before -> Method_SList, first, Nonempty_Method_SList (@
    Method_SList it = (Method_SList) history.peek();
    Nonempty_Method_SList p = new Nonempty_Method_SList();
    it.set_first(p);
    history.push(p);
  @)

  after -> Method_SList, first, Nonempty_Method_SList (@
    history.pop();
  @)

  before -> Visitor_Commalist, first, Nonempty_Visitor_Commalist (@
    Visitor_Commalist it = (Visitor_Commalist) history.peek();
    Nonempty_Visitor_Commalist p = new Nonempty_Visitor_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> Visitor_Commalist, first, Nonempty_Visitor_Commalist (@
    history.pop();
  @)

  before -> MethodKeyword_List, first, Nonempty_MethodKeyword_List (@
    MethodKeyword_List it = (MethodKeyword_List) history.peek();
    Nonempty_MethodKeyword_List p = new Nonempty_MethodKeyword_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> MethodKeyword_List, first, Nonempty_MethodKeyword_List (@
    history.pop();
  @)

  before -> MethodParm_Commalist, first, Nonempty_MethodParm_Commalist (@
    MethodParm_Commalist it = (MethodParm_Commalist) history.peek();
    Nonempty_MethodParm_Commalist p = new Nonempty_MethodParm_Commalist();
    it.set_first(p);
    history.push(p);
  @)

  after -> MethodParm_Commalist, first, Nonempty_MethodParm_Commalist (@
    history.pop();
  @)

  before -> ArraySpec_List, first, Nonempty_ArraySpec_List (@
    ArraySpec_List it = (ArraySpec_List) history.peek();
    Nonempty_ArraySpec_List p = new Nonempty_ArraySpec_List();
    it.set_first(p);
    history.push(p);
  @)

  after -> ArraySpec_List, first, Nonempty_ArraySpec_List (@
    history.pop();
  @)

  before -> Nonempty_UVertex_List, it, UVertex (@
    Nonempty_UVertex_List it = (Nonempty_UVertex_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((UVertex) p);
    history.push(p);
  @)

  after -> Nonempty_UVertex_List, it, UVertex (@
    history.pop();
  @)

  before -> Nonempty_UVertex_List, next, Nonempty_UVertex_List (@
    Nonempty_UVertex_List it = (Nonempty_UVertex_List) history.peek();
    Nonempty_UVertex_List p = new Nonempty_UVertex_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_UVertex_List, next, Nonempty_UVertex_List (@
    history.pop();
  @)

  before -> Nonempty_IEdge_List, it, UID (@
    Nonempty_IEdge_List it = (Nonempty_IEdge_List) history.peek();
    UID p = new UID();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_IEdge_List, it, UID (@
    history.pop();
  @)

  before -> Nonempty_IEdge_List, next, Nonempty_IEdge_List (@
    Nonempty_IEdge_List it = (Nonempty_IEdge_List) history.peek();
    Nonempty_IEdge_List p = new Nonempty_IEdge_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_IEdge_List, next, Nonempty_IEdge_List (@
    history.pop();
  @)

  before -> Nonempty_OEdge_List, it, UID (@
    Nonempty_OEdge_List it = (Nonempty_OEdge_List) history.peek();
    UID p = new UID();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_OEdge_List, it, UID (@
    history.pop();
  @)

  before -> Nonempty_OEdge_List, next, Nonempty_OEdge_List (@
    Nonempty_OEdge_List it = (Nonempty_OEdge_List) history.peek();
    Nonempty_OEdge_List p = new Nonempty_OEdge_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_OEdge_List, next, Nonempty_OEdge_List (@
    history.pop();
  @)

  before -> Nonempty_InterfaceModifier_List, it, InterfaceModifier (@
    Nonempty_InterfaceModifier_List it = (Nonempty_InterfaceModifier_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((InterfaceModifier) p);
    history.push(p);
  @)

  after -> Nonempty_InterfaceModifier_List, it, InterfaceModifier (@
    history.pop();
  @)

  before -> Nonempty_InterfaceModifier_List, next, Nonempty_InterfaceModifier_List (@
    Nonempty_InterfaceModifier_List it = (Nonempty_InterfaceModifier_List) history.peek();
    Nonempty_InterfaceModifier_List p = new Nonempty_InterfaceModifier_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_InterfaceModifier_List, next, Nonempty_InterfaceModifier_List (@
    history.pop();
  @)

  before -> Nonempty_ScopeIdentifier_List, it, ScopeIdentifier (@
    Nonempty_ScopeIdentifier_List it = (Nonempty_ScopeIdentifier_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((ScopeIdentifier) p);
    history.push(p);
  @)

  after -> Nonempty_ScopeIdentifier_List, it, ScopeIdentifier (@
    history.pop();
  @)

  before -> Nonempty_ScopeIdentifier_List, next, Nonempty_ScopeIdentifier_List (@
    Nonempty_ScopeIdentifier_List it = (Nonempty_ScopeIdentifier_List) history.peek();
    Nonempty_ScopeIdentifier_List p = new Nonempty_ScopeIdentifier_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ScopeIdentifier_List, next, Nonempty_ScopeIdentifier_List (@
    history.pop();
  @)

  before -> Nonempty_UEdge_List, it, UEdge (@
    Nonempty_UEdge_List it = (Nonempty_UEdge_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((UEdge) p);
    history.push(p);
  @)

  after -> Nonempty_UEdge_List, it, UEdge (@
    history.pop();
  @)

  before -> Nonempty_UEdge_List, next, Nonempty_UEdge_List (@
    Nonempty_UEdge_List it = (Nonempty_UEdge_List) history.peek();
    Nonempty_UEdge_List p = new Nonempty_UEdge_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_UEdge_List, next, Nonempty_UEdge_List (@
    history.pop();
  @)

  before -> Nonempty_PartModifier_List, it, PartModifier (@
    Nonempty_PartModifier_List it = (Nonempty_PartModifier_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((PartModifier) p);
    history.push(p);
  @)

  after -> Nonempty_PartModifier_List, it, PartModifier (@
    history.pop();
  @)

  before -> Nonempty_PartModifier_List, next, Nonempty_PartModifier_List (@
    Nonempty_PartModifier_List it = (Nonempty_PartModifier_List) history.peek();
    Nonempty_PartModifier_List p = new Nonempty_PartModifier_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_PartModifier_List, next, Nonempty_PartModifier_List (@
    history.pop();
  @)

  before -> Nonempty_PackageName, it, IdentOrKeyword (@
    Nonempty_PackageName it = (Nonempty_PackageName) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((IdentOrKeyword) p);
    history.push(p);
  @)

  after -> Nonempty_PackageName, it, IdentOrKeyword (@
    history.pop();
  @)

  before -> Nonempty_PackageName, next, Nonempty_PackageName (@
    Nonempty_PackageName it = (Nonempty_PackageName) history.peek();
    Nonempty_PackageName p = new Nonempty_PackageName();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_PackageName, next, Nonempty_PackageName (@
    history.pop();
  @)

  before -> Nonempty_Name, it, Ident (@
    Nonempty_Name it = (Nonempty_Name) history.peek();
    it.set_it(dest);
  @)

  before -> Nonempty_Name, next, Nonempty_Name (@
    Nonempty_Name it = (Nonempty_Name) history.peek();
    Nonempty_Name p = new Nonempty_Name();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Name, next, Nonempty_Name (@
    history.pop();
  @)

  before -> Nonempty_Parts, it, Part (@
    Nonempty_Parts it = (Nonempty_Parts) history.peek();
    Part p = new Part();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_Parts, it, Part (@
    history.pop();
  @)

  before -> Nonempty_Parts, next, Nonempty_Parts (@
    Nonempty_Parts it = (Nonempty_Parts) history.peek();
    Nonempty_Parts p = new Nonempty_Parts();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Parts, next, Nonempty_Parts (@
    history.pop();
  @)

  before -> Nonempty_Import_SList, it, Import (@
    Nonempty_Import_SList it = (Nonempty_Import_SList) history.peek();
    Import p = new Import();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_Import_SList, it, Import (@
    history.pop();
  @)

  before -> Nonempty_Import_SList, next, Nonempty_Import_SList (@
    Nonempty_Import_SList it = (Nonempty_Import_SList) history.peek();
    Nonempty_Import_SList p = new Nonempty_Import_SList();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Import_SList, next, Nonempty_Import_SList (@
    history.pop();
  @)

  before -> Nonempty_ClassGraphEntry_DList, it, ClassGraphEntry (@
    Nonempty_ClassGraphEntry_DList it = (Nonempty_ClassGraphEntry_DList) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((ClassGraphEntry) p);
    history.push(p);
  @)

  after -> Nonempty_ClassGraphEntry_DList, it, ClassGraphEntry (@
    history.pop();
  @)

  before -> Nonempty_ClassGraphEntry_DList, next, Nonempty_ClassGraphEntry_DList (@
    Nonempty_ClassGraphEntry_DList it = (Nonempty_ClassGraphEntry_DList) history.peek();
    Nonempty_ClassGraphEntry_DList p = new Nonempty_ClassGraphEntry_DList();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ClassGraphEntry_DList, next, Nonempty_ClassGraphEntry_DList (@
    history.pop();
  @)

  before -> Nonempty_ClassKeyword_List, it, ClassKeyword (@
    Nonempty_ClassKeyword_List it = (Nonempty_ClassKeyword_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((ClassKeyword) p);
    history.push(p);
  @)

  after -> Nonempty_ClassKeyword_List, it, ClassKeyword (@
    history.pop();
  @)

  before -> Nonempty_ClassKeyword_List, next, Nonempty_ClassKeyword_List (@
    Nonempty_ClassKeyword_List it = (Nonempty_ClassKeyword_List) history.peek();
    Nonempty_ClassKeyword_List p = new Nonempty_ClassKeyword_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ClassKeyword_List, next, Nonempty_ClassKeyword_List (@
    history.pop();
  @)

  before -> Nonempty_ClassName_Commalist, it, ClassName (@
    Nonempty_ClassName_Commalist it = (Nonempty_ClassName_Commalist) history.peek();
    ClassName p = new ClassName();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_ClassName_Commalist, it, ClassName (@
    history.pop();
  @)

  before -> Nonempty_ClassName_Commalist, next, Nonempty_ClassName_Commalist (@
    Nonempty_ClassName_Commalist it = (Nonempty_ClassName_Commalist) history.peek();
    Nonempty_ClassName_Commalist p = new Nonempty_ClassName_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ClassName_Commalist, next, Nonempty_ClassName_Commalist (@
    history.pop();
  @)

  before -> Nonempty_PartOrSyntax_List, it, PartOrSyntax (@
    Nonempty_PartOrSyntax_List it = (Nonempty_PartOrSyntax_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((PartOrSyntax) p);
    history.push(p);
  @)

  after -> Nonempty_PartOrSyntax_List, it, PartOrSyntax (@
    history.pop();
  @)

  before -> Nonempty_PartOrSyntax_List, next, Nonempty_PartOrSyntax_List (@
    Nonempty_PartOrSyntax_List it = (Nonempty_PartOrSyntax_List) history.peek();
    Nonempty_PartOrSyntax_List p = new Nonempty_PartOrSyntax_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_PartOrSyntax_List, next, Nonempty_PartOrSyntax_List (@
    history.pop();
  @)

  before -> Nonempty_PartKeyword_List, it, PartKeyword (@
    Nonempty_PartKeyword_List it = (Nonempty_PartKeyword_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((PartKeyword) p);
    history.push(p);
  @)

  after -> Nonempty_PartKeyword_List, it, PartKeyword (@
    history.pop();
  @)

  before -> Nonempty_PartKeyword_List, next, Nonempty_PartKeyword_List (@
    Nonempty_PartKeyword_List it = (Nonempty_PartKeyword_List) history.peek();
    Nonempty_PartKeyword_List p = new Nonempty_PartKeyword_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_PartKeyword_List, next, Nonempty_PartKeyword_List (@
    history.pop();
  @)

  before -> Nonempty_Superclass_Commalist, it, Superclass (@
    Nonempty_Superclass_Commalist it = (Nonempty_Superclass_Commalist) history.peek();
    Superclass p = new Superclass();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_Superclass_Commalist, it, Superclass (@
    history.pop();
  @)

  before -> Nonempty_Superclass_Commalist, next, Nonempty_Superclass_Commalist (@
    Nonempty_Superclass_Commalist it = (Nonempty_Superclass_Commalist) history.peek();
    Nonempty_Superclass_Commalist p = new Nonempty_Superclass_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Superclass_Commalist, next, Nonempty_Superclass_Commalist (@
    history.pop();
  @)

  before -> Nonempty_Interface_Commalist, it, Interface (@
    Nonempty_Interface_Commalist it = (Nonempty_Interface_Commalist) history.peek();
    Interface p = new Interface();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_Interface_Commalist, it, Interface (@
    history.pop();
  @)

  before -> Nonempty_Interface_Commalist, next, Nonempty_Interface_Commalist (@
    Nonempty_Interface_Commalist it = (Nonempty_Interface_Commalist) history.peek();
    Nonempty_Interface_Commalist p = new Nonempty_Interface_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Interface_Commalist, next, Nonempty_Interface_Commalist (@
    history.pop();
  @)

  before -> Nonempty_Subclass_Barlist, it, Subclass (@
    Nonempty_Subclass_Barlist it = (Nonempty_Subclass_Barlist) history.peek();
    Subclass p = new Subclass();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_Subclass_Barlist, it, Subclass (@
    history.pop();
  @)

  before -> Nonempty_Subclass_Barlist, next, Nonempty_Subclass_Barlist (@
    Nonempty_Subclass_Barlist it = (Nonempty_Subclass_Barlist) history.peek();
    Nonempty_Subclass_Barlist p = new Nonempty_Subclass_Barlist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Subclass_Barlist, next, Nonempty_Subclass_Barlist (@
    history.pop();
  @)

  before -> Nonempty_Syntax_List, it, Syntax (@
    Nonempty_Syntax_List it = (Nonempty_Syntax_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((Syntax) p);
    history.push(p);
  @)

  after -> Nonempty_Syntax_List, it, Syntax (@
    history.pop();
  @)

  before -> Nonempty_Syntax_List, next, Nonempty_Syntax_List (@
    Nonempty_Syntax_List it = (Nonempty_Syntax_List) history.peek();
    Nonempty_Syntax_List p = new Nonempty_Syntax_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Syntax_List, next, Nonempty_Syntax_List (@
    history.pop();
  @)

  before -> Nonempty_ClassSpec_Commalist, it, ClassSpec (@
    Nonempty_ClassSpec_Commalist it = (Nonempty_ClassSpec_Commalist) history.peek();
    ClassSpec p = new ClassSpec();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_ClassSpec_Commalist, it, ClassSpec (@
    history.pop();
  @)

  before -> Nonempty_ClassSpec_Commalist, next, Nonempty_ClassSpec_Commalist (@
    Nonempty_ClassSpec_Commalist it = (Nonempty_ClassSpec_Commalist) history.peek();
    Nonempty_ClassSpec_Commalist p = new Nonempty_ClassSpec_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ClassSpec_Commalist, next, Nonempty_ClassSpec_Commalist (@
    history.pop();
  @)

  before -> Nonempty_Behavior_DList, it, Behavior (@
    Nonempty_Behavior_DList it = (Nonempty_Behavior_DList) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((Behavior) p);
    history.push(p);
  @)

  after -> Nonempty_Behavior_DList, it, Behavior (@
    history.pop();
  @)

  before -> Nonempty_Behavior_DList, next, Nonempty_Behavior_DList (@
    Nonempty_Behavior_DList it = (Nonempty_Behavior_DList) history.peek();
    Nonempty_Behavior_DList p = new Nonempty_Behavior_DList();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Behavior_DList, next, Nonempty_Behavior_DList (@
    history.pop();
  @)

  before -> Nonempty_SGEdge_SList, it, SGEdge (@
    Nonempty_SGEdge_SList it = (Nonempty_SGEdge_SList) history.peek();
    SGEdge p = new SGEdge();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_SGEdge_SList, it, SGEdge (@
    history.pop();
  @)

  before -> Nonempty_SGEdge_SList, next, Nonempty_SGEdge_SList (@
    Nonempty_SGEdge_SList it = (Nonempty_SGEdge_SList) history.peek();
    Nonempty_SGEdge_SList p = new Nonempty_SGEdge_SList();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_SGEdge_SList, next, Nonempty_SGEdge_SList (@
    history.pop();
  @)

  before -> Nonempty_Integer_NList, it, Integer (@
    Nonempty_Integer_NList it = (Nonempty_Integer_NList) history.peek();
    it.set_it(dest);
  @)

  before -> Nonempty_Integer_NList, next, Nonempty_Integer_NList (@
    Nonempty_Integer_NList it = (Nonempty_Integer_NList) history.peek();
    Nonempty_Integer_NList p = new Nonempty_Integer_NList();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Integer_NList, next, Nonempty_Integer_NList (@
    history.pop();
  @)

  before -> Nonempty_PathSegment_List, it, PathSegment (@
    Nonempty_PathSegment_List it = (Nonempty_PathSegment_List) history.peek();
    PathSegment p = new PathSegment();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_PathSegment_List, it, PathSegment (@
    history.pop();
  @)

  before -> Nonempty_PathSegment_List, next, Nonempty_PathSegment_List (@
    Nonempty_PathSegment_List it = (Nonempty_PathSegment_List) history.peek();
    Nonempty_PathSegment_List p = new Nonempty_PathSegment_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_PathSegment_List, next, Nonempty_PathSegment_List (@
    history.pop();
  @)

  before -> Nonempty_StrategyExpression_Commalist, it, StrategyExpression (@
    Nonempty_StrategyExpression_Commalist it = (Nonempty_StrategyExpression_Commalist) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((StrategyExpression) p);
    history.push(p);
  @)

  after -> Nonempty_StrategyExpression_Commalist, it, StrategyExpression (@
    history.pop();
  @)

  before -> Nonempty_StrategyExpression_Commalist, next, Nonempty_StrategyExpression_Commalist (@
    Nonempty_StrategyExpression_Commalist it = (Nonempty_StrategyExpression_Commalist) history.peek();
    Nonempty_StrategyExpression_Commalist p = new Nonempty_StrategyExpression_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_StrategyExpression_Commalist, next, Nonempty_StrategyExpression_Commalist (@
    history.pop();
  @)

  before -> Nonempty_Glob_Commalist, it, Glob (@
    Nonempty_Glob_Commalist it = (Nonempty_Glob_Commalist) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((Glob) p);
    history.push(p);
  @)

  after -> Nonempty_Glob_Commalist, it, Glob (@
    history.pop();
  @)

  before -> Nonempty_Glob_Commalist, next, Nonempty_Glob_Commalist (@
    Nonempty_Glob_Commalist it = (Nonempty_Glob_Commalist) history.peek();
    Nonempty_Glob_Commalist p = new Nonempty_Glob_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Glob_Commalist, next, Nonempty_Glob_Commalist (@
    history.pop();
  @)

  before -> Nonempty_ClassGlob_Commalist, it, ClassGlob (@
    Nonempty_ClassGlob_Commalist it = (Nonempty_ClassGlob_Commalist) history.peek();
    ClassGlob p = new ClassGlob();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_ClassGlob_Commalist, it, ClassGlob (@
    history.pop();
  @)

  before -> Nonempty_ClassGlob_Commalist, next, Nonempty_ClassGlob_Commalist (@
    Nonempty_ClassGlob_Commalist it = (Nonempty_ClassGlob_Commalist) history.peek();
    Nonempty_ClassGlob_Commalist p = new Nonempty_ClassGlob_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ClassGlob_Commalist, next, Nonempty_ClassGlob_Commalist (@
    history.pop();
  @)

  before -> Nonempty_Method_SList, it, Method (@
    Nonempty_Method_SList it = (Nonempty_Method_SList) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((Method) p);
    history.push(p);
  @)

  after -> Nonempty_Method_SList, it, Method (@
    history.pop();
  @)

  before -> Nonempty_Method_SList, next, Nonempty_Method_SList (@
    Nonempty_Method_SList it = (Nonempty_Method_SList) history.peek();
    Nonempty_Method_SList p = new Nonempty_Method_SList();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Method_SList, next, Nonempty_Method_SList (@
    history.pop();
  @)

  before -> Nonempty_Visitor_Commalist, it, Visitor (@
    Nonempty_Visitor_Commalist it = (Nonempty_Visitor_Commalist) history.peek();
    Visitor p = new Visitor();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_Visitor_Commalist, it, Visitor (@
    history.pop();
  @)

  before -> Nonempty_Visitor_Commalist, next, Nonempty_Visitor_Commalist (@
    Nonempty_Visitor_Commalist it = (Nonempty_Visitor_Commalist) history.peek();
    Nonempty_Visitor_Commalist p = new Nonempty_Visitor_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_Visitor_Commalist, next, Nonempty_Visitor_Commalist (@
    history.pop();
  @)

  before -> Nonempty_MethodKeyword_List, it, MethodKeyword (@
    Nonempty_MethodKeyword_List it = (Nonempty_MethodKeyword_List) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((MethodKeyword) p);
    history.push(p);
  @)

  after -> Nonempty_MethodKeyword_List, it, MethodKeyword (@
    history.pop();
  @)

  before -> Nonempty_MethodKeyword_List, next, Nonempty_MethodKeyword_List (@
    Nonempty_MethodKeyword_List it = (Nonempty_MethodKeyword_List) history.peek();
    Nonempty_MethodKeyword_List p = new Nonempty_MethodKeyword_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_MethodKeyword_List, next, Nonempty_MethodKeyword_List (@
    history.pop();
  @)

  before -> Nonempty_MethodParm_Commalist, it, MethodParm (@
    Nonempty_MethodParm_Commalist it = (Nonempty_MethodParm_Commalist) history.peek();
    MethodParm p = new MethodParm();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_MethodParm_Commalist, it, MethodParm (@
    history.pop();
  @)

  before -> Nonempty_MethodParm_Commalist, next, Nonempty_MethodParm_Commalist (@
    Nonempty_MethodParm_Commalist it = (Nonempty_MethodParm_Commalist) history.peek();
    Nonempty_MethodParm_Commalist p = new Nonempty_MethodParm_Commalist();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_MethodParm_Commalist, next, Nonempty_MethodParm_Commalist (@
    history.pop();
  @)

  before -> Nonempty_ArraySpec_List, it, ArraySpec (@
    Nonempty_ArraySpec_List it = (Nonempty_ArraySpec_List) history.peek();
    ArraySpec p = new ArraySpec();
    it.set_it(p);
    history.push(p);
  @)

  after -> Nonempty_ArraySpec_List, it, ArraySpec (@
    history.pop();
  @)

  before -> Nonempty_ArraySpec_List, next, Nonempty_ArraySpec_List (@
    Nonempty_ArraySpec_List it = (Nonempty_ArraySpec_List) history.peek();
    Nonempty_ArraySpec_List p = new Nonempty_ArraySpec_List();
    it.set_next(p);
    history.push(p);
  @)

  after -> Nonempty_ArraySpec_List, next, Nonempty_ArraySpec_List (@
    history.pop();
  @)

}