// 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 -> Test, metagameinfo, MetaGameInfo {{
    Test it = (Test) history.peek();
    MetaGameInfo p = new MetaGameInfo();
    it.set_metagameinfo(p);
    history.push(p);
  }}

  after -> Test, metagameinfo, MetaGameInfo {{
    history.pop();
  }}

  before -> Test, iteratedgamehistory_list, IteratedGameHistory_List {{
    Test it = (Test) history.peek();
    IteratedGameHistory_List p = new IteratedGameHistory_List();
    it.set_iteratedgamehistory_list(p);
    history.push(p);
  }}

  after -> Test, iteratedgamehistory_list, IteratedGameHistory_List {{
    history.pop();
  }}

  before -> IteratedGameHistory, history, BasicGameStep_List {{
    IteratedGameHistory it = (IteratedGameHistory) history.peek();
    BasicGameStep_List p = new BasicGameStep_List();
    it.set_history(p);
    history.push(p);
  }}

  after -> IteratedGameHistory, history, BasicGameStep_List {{
    history.pop();
  }}

  before -> BasicGameStep, relationselection, RelationSelection {{
    BasicGameStep it = (BasicGameStep) history.peek();
    RelationSelection p = new RelationSelection();
    it.set_relationselection(p);
    history.push(p);
  }}

  after -> BasicGameStep, relationselection, RelationSelection {{
    history.pop();
  }}

  before -> BasicGameStep, firstplayer, FirstPlayer {{
    BasicGameStep it = (BasicGameStep) history.peek();
    FirstPlayer p = new FirstPlayer();
    it.set_firstplayer(p);
    history.push(p);
  }}

  after -> BasicGameStep, firstplayer, FirstPlayer {{
    history.pop();
  }}

  before -> BasicGameStep, secondplayer, SecondPlayer {{
    BasicGameStep it = (BasicGameStep) history.peek();
    SecondPlayer p = new SecondPlayer();
    it.set_secondplayer(p);
    history.push(p);
  }}

  after -> BasicGameStep, secondplayer, SecondPlayer {{
    history.pop();
  }}

  before -> BasicGameStep, negop, NegOp {{
    BasicGameStep it = (BasicGameStep) history.peek();
    NegOp p = new NegOp();
    it.set_negop(p);
    history.push(p);
  }}

  after -> BasicGameStep, negop, NegOp {{
    history.pop();
  }}

  before -> BasicGameStep, payment, float {{
    BasicGameStep it = (BasicGameStep) history.peek();
    it.set_payment(dest);
  }}

  before -> AbsPlayer, player, Player {{
    AbsPlayer it = (AbsPlayer) history.peek();
    Player p = new Player();
    it.set_player(p);
    history.push(p);
  }}

  after -> AbsPlayer, player, Player {{
    history.pop();
  }}

  before -> FirstPlayer, instance, CSP {{
    FirstPlayer it = (FirstPlayer) history.peek();
    CSP p = new CSP();
    it.set_instance(p);
    history.push(p);
  }}

  after -> FirstPlayer, instance, CSP {{
    history.pop();
  }}

  before -> SecondPlayer, literal_list, Literal_List {{
    SecondPlayer it = (SecondPlayer) history.peek();
    Literal_List p = new Literal_List();
    it.set_literal_list(p);
    history.push(p);
  }}

  after -> SecondPlayer, literal_list, Literal_List {{
    history.pop();
  }}

  before -> Literal, variable, Variable {{
    Literal it = (Literal) history.peek();
    Variable p = new Variable();
    it.set_variable(p);
    history.push(p);
  }}

  after -> Literal, variable, Variable {{
    history.pop();
  }}

  before -> RelationSelection, r1, RelationNumber {{
    RelationSelection it = (RelationSelection) history.peek();
    RelationNumber p = new RelationNumber();
    it.set_r1(p);
    history.push(p);
  }}

  after -> RelationSelection, r1, RelationNumber {{
    history.pop();
  }}

  before -> RelationSelection, r2, RelationNumber {{
    RelationSelection it = (RelationSelection) history.peek();
    RelationNumber p = new RelationNumber();
    it.set_r2(p);
    history.push(p);
  }}

  after -> RelationSelection, r2, RelationNumber {{
    history.pop();
  }}

  before -> Player, name, Name {{
    Player it = (Player) history.peek();
    Name p = new Name();
    it.set_name(p);
    history.push(p);
  }}

  after -> Player, name, Name {{
    history.pop();
  }}

  before -> Player, negop, NegOp {{
    Player it = (Player) history.peek();
    NegOp p = new NegOp();
    it.set_negop(p);
    history.push(p);
  }}

  after -> Player, negop, NegOp {{
    history.pop();
  }}

  before -> Player, gainLoss, float {{
    Player it = (Player) history.peek();
    it.set_gainLoss(dest);
  }}

  before -> MetaGameInfo, player1, MPlayer {{
    MetaGameInfo it = (MetaGameInfo) history.peek();
    MPlayer p = new MPlayer();
    it.set_player1(p);
    history.push(p);
  }}

  after -> MetaGameInfo, player1, MPlayer {{
    history.pop();
  }}

  before -> MetaGameInfo, player2, MPlayer {{
    MetaGameInfo it = (MetaGameInfo) history.peek();
    MPlayer p = new MPlayer();
    it.set_player2(p);
    history.push(p);
  }}

  after -> MetaGameInfo, player2, MPlayer {{
    history.pop();
  }}

  before -> MetaGameInfo, rsp, RelationSelectionPolicy {{
    MetaGameInfo it = (MetaGameInfo) history.peek();
    RelationSelectionPolicy p = new RelationSelectionPolicy();
    it.set_rsp(p);
    history.push(p);
  }}

  after -> MetaGameInfo, rsp, RelationSelectionPolicy {{
    history.pop();
  }}

  before -> RelationSelectionPolicy, rspName, RspName {{
    RelationSelectionPolicy it = (RelationSelectionPolicy) history.peek();
    RspName p = new RspName();
    it.set_rspName(p);
    history.push(p);
  }}

  after -> RelationSelectionPolicy, rspName, RspName {{
    history.pop();
  }}

  before -> MPlayer, solver, Solver {{
    MPlayer it = (MPlayer) history.peek();
    Solver p = new Solver();
    it.set_solver(p);
    history.push(p);
  }}

  after -> MPlayer, solver, Solver {{
    history.pop();
  }}

  before -> MPlayer, rsp, InstanceSelection {{
    MPlayer it = (MPlayer) history.peek();
    InstanceSelection p = new InstanceSelection();
    it.set_rsp(p);
    history.push(p);
  }}

  after -> MPlayer, rsp, InstanceSelection {{
    history.pop();
  }}

  before -> Solver, solverName, SolverName {{
    Solver it = (Solver) history.peek();
    SolverName p = new SolverName();
    it.set_solverName(p);
    history.push(p);
  }}

  after -> Solver, solverName, SolverName {{
    history.pop();
  }}

  before -> InstanceSelection, instSelName, InstSelName {{
    InstanceSelection it = (InstanceSelection) history.peek();
    InstSelName p = new InstSelName();
    it.set_instSelName(p);
    history.push(p);
  }}

  after -> InstanceSelection, instSelName, InstSelName {{
    history.pop();
  }}

  before -> SolverName, v, String {{
    SolverName it = (SolverName) history.peek();
    it.set_v(dest);
  }}

  before -> RspName, v, String {{
    RspName it = (RspName) history.peek();
    it.set_v(dest);
  }}

  before -> InstSelName, string, String {{
    InstSelName it = (InstSelName) history.peek();
    it.set_string(dest);
  }}

  before -> Name, v, Ident {{
    Name it = (Name) history.peek();
    it.set_v(dest);
  }}

  before -> RelationNumber, v, int {{
    RelationNumber it = (RelationNumber) history.peek();
    it.set_v(dest);
  }}

  before -> Variable, v, int {{
    Variable it = (Variable) history.peek();
    it.set_v(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 -> IteratedGameHistory_List, first, Nonempty_IteratedGameHistory_List {{
    IteratedGameHistory_List it = (IteratedGameHistory_List) history.peek();
    Nonempty_IteratedGameHistory_List p = new Nonempty_IteratedGameHistory_List();
    it.set_first(p);
    history.push(p);
  }}

  after -> IteratedGameHistory_List, first, Nonempty_IteratedGameHistory_List {{
    history.pop();
  }}

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

  after -> BasicGameStep_List, first, Nonempty_BasicGameStep_List {{
    history.pop();
  }}

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

  after -> Literal_List, first, Nonempty_Literal_List {{
    history.pop();
  }}

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

  after -> Nonempty_IteratedGameHistory_List, it, IteratedGameHistory {{
    history.pop();
  }}

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

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

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

  after -> Nonempty_BasicGameStep_List, it, BasicGameStep {{
    history.pop();
  }}

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

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

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

  after -> Nonempty_Literal_List, it, Literal {{
    history.pop();
  }}

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

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

}