// This file is automatically generated by DemeterJ.

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 -> StrategyExpression, strategy, Strategy {{
    StrategyExpression it = (StrategyExpression) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_strategy((Strategy) p);
    history.push(p);
  }}

  after -> StrategyExpression, strategy, Strategy {{
    history.pop();
  }}

  before -> SimpleStrategy, parsedNameMap, NameMap {{
    SimpleStrategy it = (SimpleStrategy) history.peek();
    NameMap p = new NameMap();
    it.set_parsedNameMap(p);
    history.push(p);
  }}

  after -> SimpleStrategy, parsedNameMap, NameMap {{
    history.pop();
  }}

  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 -> SGEdge, sourcemarker, SourceMarker {{
    SGEdge it = (SGEdge) history.peek();
    SourceMarker p = new SourceMarker();
    it.set_sourcemarker(p);
    history.push(p);
  }}

  after -> SGEdge, sourcemarker, SourceMarker {{
    history.pop();
  }}

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

  after -> SGEdge, source, GlobSpec {{
    history.pop();
  }}

  before -> SGEdge, targetmarker, TargetMarker {{
    SGEdge it = (SGEdge) history.peek();
    TargetMarker p = new TargetMarker();
    it.set_targetmarker(p);
    history.push(p);
  }}

  after -> SGEdge, targetmarker, TargetMarker {{
    history.pop();
  }}

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

  after -> SGEdge, target, GlobSpec {{
    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, source, SourceDirective {{
    PathDirective it = (PathDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_source((SourceDirective) p);
    history.push(p);
  }}

  after -> PathDirective, source, SourceDirective {{
    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, target, TargetDirective {{
    PathDirective it = (PathDirective) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_target((TargetDirective) p);
    history.push(p);
  }}

  after -> PathDirective, target, TargetDirective {{
    history.pop();
  }}

  before -> SourceDirective, sources, ClassGlobSpec {{
    SourceDirective it = (SourceDirective) 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 -> SourceDirective, sources, ClassGlobSpec {{
    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 -> StrategyCombination, first, Strategy {{
    StrategyCombination it = (StrategyCombination) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_first((Strategy) p);
    history.push(p);
  }}

  after -> StrategyCombination, first, Strategy {{
    history.pop();
  }}

  before -> StrategyCombination, rest, Strategy_Commalist {{
    StrategyCombination it = (StrategyCombination) history.peek();
    Strategy_Commalist p = new Strategy_Commalist();
    it.set_rest(p);
    history.push(p);
  }}

  after -> StrategyCombination, rest, Strategy_Commalist {{
    history.pop();
  }}

  before -> StrategyReference, ident, Ident {{
    StrategyReference it = (StrategyReference) history.peek();
    it.set_ident(dest);
  }}

  before -> NameMap, bindings, NameBinding_Commalist {{
    NameMap it = (NameMap) history.peek();
    NameBinding_Commalist p = new NameBinding_Commalist();
    it.set_bindings(p);
    history.push(p);
  }}

  after -> NameMap, bindings, NameBinding_Commalist {{
    history.pop();
  }}

  before -> NameBinding, sgName, Name {{
    NameBinding it = (NameBinding) history.peek();
    Name p = new Name();
    it.set_sgName(p);
    history.push(p);
  }}

  after -> NameBinding, sgName, Name {{
    history.pop();
  }}

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

  after -> NameBinding, cgNames, ClassGlobSpec {{
    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, target, TargetGlob {{
    PartGlob it = (PartGlob) history.peek();
    TargetGlob p = new TargetGlob();
    it.set_target(p);
    history.push(p);
  }}

  after -> PartGlob, target, TargetGlob {{
    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, target, TargetGlob {{
    SubclassGlob it = (SubclassGlob) history.peek();
    TargetGlob p = new TargetGlob();
    it.set_target(p);
    history.push(p);
  }}

  after -> SubclassGlob, target, TargetGlob {{
    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, target, TargetGlob {{
    SuperclassGlob it = (SuperclassGlob) history.peek();
    TargetGlob p = new TargetGlob();
    it.set_target(p);
    history.push(p);
  }}

  after -> SuperclassGlob, target, TargetGlob {{
    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 -> TargetGlob, name, ClassNameGlob {{
    TargetGlob it = (TargetGlob) 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 -> TargetGlob, 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 -> 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, Ident {{
    PartName it = (PartName) history.peek();
    it.set_name(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 -> XAspect, cd, XAspectCD {{
    XAspect it = (XAspect) history.peek();
    XAspectCD p = new XAspectCD();
    it.set_cd(p);
    history.push(p);
  }}

  after -> XAspect, cd, XAspectCD {{
    history.pop();
  }}

  before -> XAspect, trav, XAspectTraversals {{
    XAspect it = (XAspect) history.peek();
    XAspectTraversals p = new XAspectTraversals();
    it.set_trav(p);
    history.push(p);
  }}

  after -> XAspect, trav, XAspectTraversals {{
    history.pop();
  }}

  before -> XAspectCD, cdName, Ident {{
    XAspectCD it = (XAspectCD) history.peek();
    it.set_cdName(dest);
  }}

  before -> XAspectCD, cdText, Text {{
    XAspectCD it = (XAspectCD) history.peek();
    it.set_cdText(dest);
  }}

  before -> XAspectTraversals, travName, Ident {{
    XAspectTraversals it = (XAspectTraversals) history.peek();
    it.set_travName(dest);
  }}

  before -> XAspectTraversals, strategies, AspectStrategy_List {{
    XAspectTraversals it = (XAspectTraversals) history.peek();
    AspectStrategy_List p = new AspectStrategy_List();
    it.set_strategies(p);
    history.push(p);
  }}

  after -> XAspectTraversals, strategies, AspectStrategy_List {{
    history.pop();
  }}

  before -> XAspectTraversals, nodes, AspectNodeSet_List {{
    XAspectTraversals it = (XAspectTraversals) history.peek();
    AspectNodeSet_List p = new AspectNodeSet_List();
    it.set_nodes(p);
    history.push(p);
  }}

  after -> XAspectTraversals, nodes, AspectNodeSet_List {{
    history.pop();
  }}

  before -> AspectStrategy, strategyName, Ident {{
    AspectStrategy it = (AspectStrategy) history.peek();
    it.set_strategyName(dest);
  }}

  before -> AspectStrategy, strategy, Strategy {{
    AspectStrategy it = (AspectStrategy) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_strategy((Strategy) p);
    history.push(p);
  }}

  after -> AspectStrategy, strategy, Strategy {{
    history.pop();
  }}

  before -> AspectNodeSet, nodesetName, Ident {{
    AspectNodeSet it = (AspectNodeSet) history.peek();
    it.set_nodesetName(dest);
  }}

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

  after -> AspectNodeSet, node, Node {{
    history.pop();
  }}

  before -> Nodes, strategyName, Ident {{
    Nodes it = (Nodes) history.peek();
    it.set_strategyName(dest);
  }}

  before -> NodeList, nodeclassname_commalist, NodeClassName_Commalist {{
    NodeList it = (NodeList) history.peek();
    NodeClassName_Commalist p = new NodeClassName_Commalist();
    it.set_nodeclassname_commalist(p);
    history.push(p);
  }}

  after -> NodeList, nodeclassname_commalist, NodeClassName_Commalist {{
    history.pop();
  }}

  before -> NodeClassName, ident, Ident {{
    NodeClassName it = (NodeClassName) history.peek();
    it.set_ident(dest);
  }}

  before -> NodeRegExp, regExp, Ident {{
    NodeRegExp it = (NodeRegExp) history.peek();
    it.set_regExp(dest);
  }}

  before -> NodeExpOr, p1, NodeExpL2 {{
    NodeExpOr it = (NodeExpOr) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p1((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpOr, p1, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpOr, p2, NodeExpL2 {{
    NodeExpOr it = (NodeExpOr) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p2((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpOr, p2, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpAnd, p1, NodeExpL2 {{
    NodeExpAnd it = (NodeExpAnd) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p1((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpAnd, p1, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpAnd, p2, NodeExpL2 {{
    NodeExpAnd it = (NodeExpAnd) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p2((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpAnd, p2, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpNot, p1, NodeExpL2 {{
    NodeExpNot it = (NodeExpNot) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p1((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpNot, p1, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpOrL2, p1, NodeExpL2 {{
    NodeExpOrL2 it = (NodeExpOrL2) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p1((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpOrL2, p1, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpOrL2, p2, NodeExpL2 {{
    NodeExpOrL2 it = (NodeExpOrL2) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p2((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpOrL2, p2, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpAndL2, p1, NodeExpL2 {{
    NodeExpAndL2 it = (NodeExpAndL2) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p1((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpAndL2, p1, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpAndL2, p2, NodeExpL2 {{
    NodeExpAndL2 it = (NodeExpAndL2) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p2((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpAndL2, p2, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpNotL2, p1, NodeExpL2 {{
    NodeExpNotL2 it = (NodeExpNotL2) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_p1((NodeExpL2) p);
    history.push(p);
  }}

  after -> NodeExpNotL2, p1, NodeExpL2 {{
    history.pop();
  }}

  before -> NodeExpIdentL2, nodeSetName, Ident {{
    NodeExpIdentL2 it = (NodeExpIdentL2) history.peek();
    it.set_nodeSetName(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 -> SubgraphVisitor, is_equal, boolean {{
    SubgraphVisitor it = (SubgraphVisitor) history.peek();
    it.set_is_equal(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 -> 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 -> 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 -> Strategy_Commalist, first, Nonempty_Strategy_Commalist {{
    Strategy_Commalist it = (Strategy_Commalist) history.peek();
    Nonempty_Strategy_Commalist p = new Nonempty_Strategy_Commalist();
    it.set_first(p);
    history.push(p);
  }}

  after -> Strategy_Commalist, first, Nonempty_Strategy_Commalist {{
    history.pop();
  }}

  before -> NameBinding_Commalist, first, Nonempty_NameBinding_Commalist {{
    NameBinding_Commalist it = (NameBinding_Commalist) history.peek();
    Nonempty_NameBinding_Commalist p = new Nonempty_NameBinding_Commalist();
    it.set_first(p);
    history.push(p);
  }}

  after -> NameBinding_Commalist, first, Nonempty_NameBinding_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 -> AspectStrategy_List, first, Nonempty_AspectStrategy_List {{
    AspectStrategy_List it = (AspectStrategy_List) history.peek();
    Nonempty_AspectStrategy_List p = new Nonempty_AspectStrategy_List();
    it.set_first(p);
    history.push(p);
  }}

  after -> AspectStrategy_List, first, Nonempty_AspectStrategy_List {{
    history.pop();
  }}

  before -> AspectNodeSet_List, first, Nonempty_AspectNodeSet_List {{
    AspectNodeSet_List it = (AspectNodeSet_List) history.peek();
    Nonempty_AspectNodeSet_List p = new Nonempty_AspectNodeSet_List();
    it.set_first(p);
    history.push(p);
  }}

  after -> AspectNodeSet_List, first, Nonempty_AspectNodeSet_List {{
    history.pop();
  }}

  before -> NodeClassName_Commalist, first, Nonempty_NodeClassName_Commalist {{
    NodeClassName_Commalist it = (NodeClassName_Commalist) history.peek();
    Nonempty_NodeClassName_Commalist p = new Nonempty_NodeClassName_Commalist();
    it.set_first(p);
    history.push(p);
  }}

  after -> NodeClassName_Commalist, first, Nonempty_NodeClassName_Commalist {{
    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_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_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_Strategy_Commalist, it, Strategy {{
    Nonempty_Strategy_Commalist it = (Nonempty_Strategy_Commalist) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_it((Strategy) p);
    history.push(p);
  }}

  after -> Nonempty_Strategy_Commalist, it, Strategy {{
    history.pop();
  }}

  before -> Nonempty_Strategy_Commalist, next, Nonempty_Strategy_Commalist {{
    Nonempty_Strategy_Commalist it = (Nonempty_Strategy_Commalist) history.peek();
    Nonempty_Strategy_Commalist p = new Nonempty_Strategy_Commalist();
    it.set_next(p);
    history.push(p);
  }}

  after -> Nonempty_Strategy_Commalist, next, Nonempty_Strategy_Commalist {{
    history.pop();
  }}

  before -> Nonempty_NameBinding_Commalist, it, NameBinding {{
    Nonempty_NameBinding_Commalist it = (Nonempty_NameBinding_Commalist) history.peek();
    NameBinding p = new NameBinding();
    it.set_it(p);
    history.push(p);
  }}

  after -> Nonempty_NameBinding_Commalist, it, NameBinding {{
    history.pop();
  }}

  before -> Nonempty_NameBinding_Commalist, next, Nonempty_NameBinding_Commalist {{
    Nonempty_NameBinding_Commalist it = (Nonempty_NameBinding_Commalist) history.peek();
    Nonempty_NameBinding_Commalist p = new Nonempty_NameBinding_Commalist();
    it.set_next(p);
    history.push(p);
  }}

  after -> Nonempty_NameBinding_Commalist, next, Nonempty_NameBinding_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_AspectStrategy_List, it, AspectStrategy {{
    Nonempty_AspectStrategy_List it = (Nonempty_AspectStrategy_List) history.peek();
    AspectStrategy p = new AspectStrategy();
    it.set_it(p);
    history.push(p);
  }}

  after -> Nonempty_AspectStrategy_List, it, AspectStrategy {{
    history.pop();
  }}

  before -> Nonempty_AspectStrategy_List, next, Nonempty_AspectStrategy_List {{
    Nonempty_AspectStrategy_List it = (Nonempty_AspectStrategy_List) history.peek();
    Nonempty_AspectStrategy_List p = new Nonempty_AspectStrategy_List();
    it.set_next(p);
    history.push(p);
  }}

  after -> Nonempty_AspectStrategy_List, next, Nonempty_AspectStrategy_List {{
    history.pop();
  }}

  before -> Nonempty_AspectNodeSet_List, it, AspectNodeSet {{
    Nonempty_AspectNodeSet_List it = (Nonempty_AspectNodeSet_List) history.peek();
    AspectNodeSet p = new AspectNodeSet();
    it.set_it(p);
    history.push(p);
  }}

  after -> Nonempty_AspectNodeSet_List, it, AspectNodeSet {{
    history.pop();
  }}

  before -> Nonempty_AspectNodeSet_List, next, Nonempty_AspectNodeSet_List {{
    Nonempty_AspectNodeSet_List it = (Nonempty_AspectNodeSet_List) history.peek();
    Nonempty_AspectNodeSet_List p = new Nonempty_AspectNodeSet_List();
    it.set_next(p);
    history.push(p);
  }}

  after -> Nonempty_AspectNodeSet_List, next, Nonempty_AspectNodeSet_List {{
    history.pop();
  }}

  before -> Nonempty_NodeClassName_Commalist, it, NodeClassName {{
    Nonempty_NodeClassName_Commalist it = (Nonempty_NodeClassName_Commalist) history.peek();
    NodeClassName p = new NodeClassName();
    it.set_it(p);
    history.push(p);
  }}

  after -> Nonempty_NodeClassName_Commalist, it, NodeClassName {{
    history.pop();
  }}

  before -> Nonempty_NodeClassName_Commalist, next, Nonempty_NodeClassName_Commalist {{
    Nonempty_NodeClassName_Commalist it = (Nonempty_NodeClassName_Commalist) history.peek();
    Nonempty_NodeClassName_Commalist p = new Nonempty_NodeClassName_Commalist();
    it.set_next(p);
    history.push(p);
  }}

  after -> Nonempty_NodeClassName_Commalist, next, Nonempty_NodeClassName_Commalist {{
    history.pop();
  }}

}