// 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 -> Output, solution, Solution {{
    Output it = (Output) history.peek();
    Class c = dest.getClass();
    Object p = null;
    try {
      p = c.newInstance();
    } catch(Exception e) {
      e.printStackTrace();
    }
    it.set_solution((Solution) p);
    history.push(p);
  }}

  after -> Output, solution, Solution {{
    history.pop();
  }}

  before -> Output, diagnostics, Diagnostics {{
    Output it = (Output) history.peek();
    Diagnostics p = new Diagnostics();
    it.set_diagnostics(p);
    history.push(p);
  }}

  after -> Output, diagnostics, Diagnostics {{
    history.pop();
  }}

  before -> SAT, assignment, Assignment {{
    SAT it = (SAT) history.peek();
    Assignment p = new Assignment();
    it.set_assignment(p);
    history.push(p);
  }}

  after -> SAT, assignment, Assignment {{
    history.pop();
  }}

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

  after -> Assignment, 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 -> Variable, v, Ident {{
    Variable it = (Variable) history.peek();
    it.set_v(dest);
  }}

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

  after -> UNSAT, optionalproof, OptionalProof {{
    history.pop();
  }}

  before -> Diagnostics, up, UP {{
    Diagnostics it = (Diagnostics) history.peek();
    UP p = new UP();
    it.set_up(p);
    history.push(p);
  }}

  after -> Diagnostics, up, UP {{
    history.pop();
  }}

  before -> Diagnostics, d, D {{
    Diagnostics it = (Diagnostics) history.peek();
    D p = new D();
    it.set_d(p);
    history.push(p);
  }}

  after -> Diagnostics, d, D {{
    history.pop();
  }}

  before -> Diagnostics, ssr, SSR {{
    Diagnostics it = (Diagnostics) history.peek();
    SSR p = new SSR();
    it.set_ssr(p);
    history.push(p);
  }}

  after -> Diagnostics, ssr, SSR {{
    history.pop();
  }}

  before -> Diagnostics, b, B {{
    Diagnostics it = (Diagnostics) history.peek();
    B p = new B();
    it.set_b(p);
    history.push(p);
  }}

  after -> Diagnostics, b, B {{
    history.pop();
  }}

  before -> Diagnostics, tssr, TSSR {{
    Diagnostics it = (Diagnostics) history.peek();
    TSSR p = new TSSR();
    it.set_tssr(p);
    history.push(p);
  }}

  after -> Diagnostics, tssr, TSSR {{
    history.pop();
  }}

  before -> Diagnostics, nv, NV {{
    Diagnostics it = (Diagnostics) history.peek();
    NV p = new NV();
    it.set_nv(p);
    history.push(p);
  }}

  after -> Diagnostics, nv, NV {{
    history.pop();
  }}

  before -> UP, up, Number {{
    UP it = (UP) history.peek();
    it.set_up(dest);
  }}

  before -> D, d, Number {{
    D it = (D) history.peek();
    it.set_d(dest);
  }}

  before -> SSR, ssr, Number {{
    SSR it = (SSR) history.peek();
    it.set_ssr(dest);
  }}

  before -> B, b, Number {{
    B it = (B) history.peek();
    it.set_b(dest);
  }}

  before -> TSSR, tssr, Number {{
    TSSR it = (TSSR) history.peek();
    it.set_tssr(dest);
  }}

  before -> NV, nv, Number {{
    NV it = (NV) history.peek();
    it.set_nv(dest);
  }}

  before -> Proof, proof, Text {{
    Proof it = (Proof) history.peek();
    it.set_proof(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 -> 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_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();
  }}

}