// Do not edit this file!
//
// Automatically generated by Emacs:
//
//    node defs:  nodetypes.def
//    builder  :  tree-clone.cc.el
//    timestamp:  Mon Aug 22 04:09:13 2005


#include <iostream>

#include "AST.h"
#include "c-types/CtType.h"


TypeListNode *TypeListNode::clone () const
{
  TypeListNode* copy = new TypeListNode; *copy = *this;
  copy->children = new TreeNode*[_arity];
  memcpy(copy->children, children, _arity * sizeof(*children));
  return copy;
}

TypeListNode *TypeListNode::deepClone () const
{
  TypeListNode * const copy = new TypeListNode;
  *copy = *this;
  copy->children = new TreeNode*[_arity];
  deepCloneChildren(*copy);
  return copy;
}


NameNode *NameNode::clone () const
{
  NameNode* copy = new NameNode(*this);
  copy->children = copy->_children; return copy;
}

NameNode *NameNode::deepClone () const
{
  NameNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PrimitiveLitNode *PrimitiveLitNode::clone () const
{
  PrimitiveLitNode* copy = new PrimitiveLitNode(*this);
  copy->children = NULL; return copy;
}

PrimitiveLitNode *PrimitiveLitNode::deepClone () const
{
  PrimitiveLitNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


StringLitNode *StringLitNode::clone () const
{
  StringLitNode* copy = new StringLitNode(*this);
  copy->children = NULL; return copy;
}

StringLitNode *StringLitNode::deepClone () const
{
  StringLitNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BoolTypeNode *BoolTypeNode::clone () const
{
  BoolTypeNode* copy = new BoolTypeNode(*this);
  copy->children = NULL; return copy;
}

BoolTypeNode *BoolTypeNode::deepClone () const
{
  BoolTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CharTypeNode *CharTypeNode::clone () const
{
  CharTypeNode* copy = new CharTypeNode(*this);
  copy->children = NULL; return copy;
}

CharTypeNode *CharTypeNode::deepClone () const
{
  CharTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ByteTypeNode *ByteTypeNode::clone () const
{
  ByteTypeNode* copy = new ByteTypeNode(*this);
  copy->children = NULL; return copy;
}

ByteTypeNode *ByteTypeNode::deepClone () const
{
  ByteTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ShortTypeNode *ShortTypeNode::clone () const
{
  ShortTypeNode* copy = new ShortTypeNode(*this);
  copy->children = NULL; return copy;
}

ShortTypeNode *ShortTypeNode::deepClone () const
{
  ShortTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


IntTypeNode *IntTypeNode::clone () const
{
  IntTypeNode* copy = new IntTypeNode(*this);
  copy->children = NULL; return copy;
}

IntTypeNode *IntTypeNode::deepClone () const
{
  IntTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


FloatTypeNode *FloatTypeNode::clone () const
{
  FloatTypeNode* copy = new FloatTypeNode(*this);
  copy->children = NULL; return copy;
}

FloatTypeNode *FloatTypeNode::deepClone () const
{
  FloatTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LongTypeNode *LongTypeNode::clone () const
{
  LongTypeNode* copy = new LongTypeNode(*this);
  copy->children = NULL; return copy;
}

LongTypeNode *LongTypeNode::deepClone () const
{
  LongTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DoubleTypeNode *DoubleTypeNode::clone () const
{
  DoubleTypeNode* copy = new DoubleTypeNode(*this);
  copy->children = NULL; return copy;
}

DoubleTypeNode *DoubleTypeNode::deepClone () const
{
  DoubleTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TypeNameNode *TypeNameNode::clone () const
{
  TypeNameNode* copy = new TypeNameNode(*this);
  copy->children = copy->_children; return copy;
}

TypeNameNode *TypeNameNode::deepClone () const
{
  TypeNameNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


JavaArrayTypeNode *JavaArrayTypeNode::clone () const
{
  JavaArrayTypeNode* copy = new JavaArrayTypeNode(*this);
  copy->children = copy->_children; return copy;
}

JavaArrayTypeNode *JavaArrayTypeNode::deepClone () const
{
  JavaArrayTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CompileUnitNode *CompileUnitNode::clone () const
{
  CompileUnitNode* copy = new CompileUnitNode(*this);
  copy->children = copy->_children; return copy;
}

CompileUnitNode *CompileUnitNode::deepClone () const
{
  CompileUnitNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ImportNode *ImportNode::clone () const
{
  ImportNode* copy = new ImportNode(*this);
  copy->children = copy->_children; return copy;
}

ImportNode *ImportNode::deepClone () const
{
  ImportNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ImportOnDemandNode *ImportOnDemandNode::clone () const
{
  ImportOnDemandNode* copy = new ImportOnDemandNode(*this);
  copy->children = copy->_children; return copy;
}

ImportOnDemandNode *ImportOnDemandNode::deepClone () const
{
  ImportOnDemandNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ClassDeclNode *ClassDeclNode::clone () const
{
  ClassDeclNode* copy = new ClassDeclNode(*this);
  copy->children = copy->_children; return copy;
}

ClassDeclNode *ClassDeclNode::deepClone () const
{
  ClassDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


FieldDeclNode *FieldDeclNode::clone () const
{
  FieldDeclNode* copy = new FieldDeclNode(*this);
  copy->children = copy->_children; return copy;
}

FieldDeclNode *FieldDeclNode::deepClone () const
{
  FieldDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


VarDeclNode *VarDeclNode::clone () const
{
  VarDeclNode* copy = new VarDeclNode(*this);
  copy->children = copy->_children; return copy;
}

VarDeclNode *VarDeclNode::deepClone () const
{
  VarDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MethodDeclNode *MethodDeclNode::clone () const
{
  MethodDeclNode* copy = new MethodDeclNode(*this);
  copy->children = copy->_children; return copy;
}

MethodDeclNode *MethodDeclNode::deepClone () const
{
  MethodDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MethodSignatureNode *MethodSignatureNode::clone () const
{
  MethodSignatureNode* copy = new MethodSignatureNode(*this);
  copy->children = copy->_children; return copy;
}

MethodSignatureNode *MethodSignatureNode::deepClone () const
{
  MethodSignatureNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


OverlapNode *OverlapNode::clone () const
{
  OverlapNode* copy = new OverlapNode(*this);
  copy->children = copy->_children; return copy;
}

OverlapNode *OverlapNode::deepClone () const
{
  OverlapNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


VoidTypeNode *VoidTypeNode::clone () const
{
  VoidTypeNode* copy = new VoidTypeNode(*this);
  copy->children = NULL; return copy;
}

VoidTypeNode *VoidTypeNode::deepClone () const
{
  VoidTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ConstructorDeclNode *ConstructorDeclNode::clone () const
{
  ConstructorDeclNode* copy = new ConstructorDeclNode(*this);
  copy->children = copy->_children; return copy;
}

ConstructorDeclNode *ConstructorDeclNode::deepClone () const
{
  ConstructorDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ThisConstructorCallNode *ThisConstructorCallNode::clone () const
{
  ThisConstructorCallNode* copy = new ThisConstructorCallNode(*this);
  copy->children = copy->_children; return copy;
}

ThisConstructorCallNode *ThisConstructorCallNode::deepClone () const
{
  ThisConstructorCallNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


SuperConstructorCallNode *SuperConstructorCallNode::clone () const
{
  SuperConstructorCallNode* copy = new SuperConstructorCallNode(*this);
  copy->children = copy->_children; return copy;
}

SuperConstructorCallNode *SuperConstructorCallNode::deepClone () const
{
  SuperConstructorCallNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


StaticInitNode *StaticInitNode::clone () const
{
  StaticInitNode* copy = new StaticInitNode(*this);
  copy->children = copy->_children; return copy;
}

StaticInitNode *StaticInitNode::deepClone () const
{
  StaticInitNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


InstanceInitNode *InstanceInitNode::clone () const
{
  InstanceInitNode* copy = new InstanceInitNode(*this);
  copy->children = copy->_children; return copy;
}

InstanceInitNode *InstanceInitNode::deepClone () const
{
  InstanceInitNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


InterfaceDeclNode *InterfaceDeclNode::clone () const
{
  InterfaceDeclNode* copy = new InterfaceDeclNode(*this);
  copy->children = copy->_children; return copy;
}

InterfaceDeclNode *InterfaceDeclNode::deepClone () const
{
  InterfaceDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ArrayInitNode *ArrayInitNode::clone () const
{
  ArrayInitNode* copy = new ArrayInitNode(*this);
  copy->children = copy->_children; return copy;
}

ArrayInitNode *ArrayInitNode::deepClone () const
{
  ArrayInitNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BlockNode *BlockNode::clone () const
{
  BlockNode* copy = new BlockNode(*this);
  copy->children = copy->_children; return copy;
}

BlockNode *BlockNode::deepClone () const
{
  BlockNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


EmptyStmtNode *EmptyStmtNode::clone () const
{
  EmptyStmtNode* copy = new EmptyStmtNode(*this);
  copy->children = NULL; return copy;
}

EmptyStmtNode *EmptyStmtNode::deepClone () const
{
  EmptyStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


GotoNode *GotoNode::clone () const
{
  GotoNode* copy = new GotoNode(*this);
  copy->children = NULL; return copy;
}

GotoNode *GotoNode::deepClone () const
{
  GotoNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LabeledStmtNode *LabeledStmtNode::clone () const
{
  LabeledStmtNode* copy = new LabeledStmtNode(*this);
  copy->children = copy->_children; return copy;
}

LabeledStmtNode *LabeledStmtNode::deepClone () const
{
  LabeledStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


IfStmtNode *IfStmtNode::clone () const
{
  IfStmtNode* copy = new IfStmtNode(*this);
  copy->children = copy->_children; return copy;
}

IfStmtNode *IfStmtNode::deepClone () const
{
  IfStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


SwitchNode *SwitchNode::clone () const
{
  SwitchNode* copy = new SwitchNode(*this);
  copy->children = copy->_children; return copy;
}

SwitchNode *SwitchNode::deepClone () const
{
  SwitchNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CaseNode *CaseNode::clone () const
{
  CaseNode* copy = new CaseNode(*this);
  copy->children = copy->_children; return copy;
}

CaseNode *CaseNode::deepClone () const
{
  CaseNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


SwitchBranchNode *SwitchBranchNode::clone () const
{
  SwitchBranchNode* copy = new SwitchBranchNode(*this);
  copy->children = copy->_children; return copy;
}

SwitchBranchNode *SwitchBranchNode::deepClone () const
{
  SwitchBranchNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


WhileNode *WhileNode::clone () const
{
  WhileNode* copy = new WhileNode(*this);
  copy->children = copy->_children; return copy;
}

WhileNode *WhileNode::deepClone () const
{
  WhileNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DoNode *DoNode::clone () const
{
  DoNode* copy = new DoNode(*this);
  copy->children = copy->_children; return copy;
}

DoNode *DoNode::deepClone () const
{
  DoNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ForNode *ForNode::clone () const
{
  ForNode* copy = new ForNode(*this);
  copy->children = copy->_children; return copy;
}

ForNode *ForNode::deepClone () const
{
  ForNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BreakNode *BreakNode::clone () const
{
  BreakNode* copy = new BreakNode(*this);
  copy->children = copy->_children; return copy;
}

BreakNode *BreakNode::deepClone () const
{
  BreakNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ContinueNode *ContinueNode::clone () const
{
  ContinueNode* copy = new ContinueNode(*this);
  copy->children = copy->_children; return copy;
}

ContinueNode *ContinueNode::deepClone () const
{
  ContinueNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ReturnNode *ReturnNode::clone () const
{
  ReturnNode* copy = new ReturnNode(*this);
  copy->children = copy->_children; return copy;
}

ReturnNode *ReturnNode::deepClone () const
{
  ReturnNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ThrowNode *ThrowNode::clone () const
{
  ThrowNode* copy = new ThrowNode(*this);
  copy->children = copy->_children; return copy;
}

ThrowNode *ThrowNode::deepClone () const
{
  ThrowNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


SynchronizedNode *SynchronizedNode::clone () const
{
  SynchronizedNode* copy = new SynchronizedNode(*this);
  copy->children = copy->_children; return copy;
}

SynchronizedNode *SynchronizedNode::deepClone () const
{
  SynchronizedNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CatchNode *CatchNode::clone () const
{
  CatchNode* copy = new CatchNode(*this);
  copy->children = copy->_children; return copy;
}

CatchNode *CatchNode::deepClone () const
{
  CatchNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TryNode *TryNode::clone () const
{
  TryNode* copy = new TryNode(*this);
  copy->children = copy->_children; return copy;
}

TryNode *TryNode::deepClone () const
{
  TryNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CatchListNode *CatchListNode::clone () const
{
  CatchListNode* copy = new CatchListNode; *copy = *this;
  copy->children = new TreeNode*[_arity];
  memcpy(copy->children, children, _arity * sizeof(*children));
  return copy;
}

CatchListNode *CatchListNode::deepClone () const
{
  CatchListNode * const copy = new CatchListNode;
  *copy = *this;
  copy->children = new TreeNode*[_arity];
  deepCloneChildren(*copy);
  return copy;
}


FinallyNode *FinallyNode::clone () const
{
  FinallyNode* copy = new FinallyNode(*this);
  copy->children = copy->_children; return copy;
}

FinallyNode *FinallyNode::deepClone () const
{
  FinallyNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TryStmtNode *TryStmtNode::clone () const
{
  TryStmtNode* copy = new TryStmtNode(*this);
  copy->children = copy->_children; return copy;
}

TryStmtNode *TryStmtNode::deepClone () const
{
  TryStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ExpressionStmtNode *ExpressionStmtNode::clone () const
{
  ExpressionStmtNode* copy = new ExpressionStmtNode(*this);
  copy->children = copy->_children; return copy;
}

ExpressionStmtNode *ExpressionStmtNode::deepClone () const
{
  ExpressionStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DummyNode *DummyNode::clone () const
{
  DummyNode* copy = new DummyNode(*this);
  copy->children = copy->_children; return copy;
}

DummyNode *DummyNode::deepClone () const
{
  DummyNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ParameterNode *ParameterNode::clone () const
{
  ParameterNode* copy = new ParameterNode(*this);
  copy->children = copy->_children; return copy;
}

ParameterNode *ParameterNode::deepClone () const
{
  ParameterNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


NullPntrNode *NullPntrNode::clone () const
{
  NullPntrNode* copy = new NullPntrNode(*this);
  copy->children = NULL; return copy;
}

NullPntrNode *NullPntrNode::deepClone () const
{
  NullPntrNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ThisNode *ThisNode::clone () const
{
  ThisNode* copy = new ThisNode(*this);
  copy->children = copy->_children; return copy;
}

ThisNode *ThisNode::deepClone () const
{
  ThisNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ArrayAccessNode *ArrayAccessNode::clone () const
{
  ArrayAccessNode* copy = new ArrayAccessNode(*this);
  copy->children = copy->_children; return copy;
}

ArrayAccessNode *ArrayAccessNode::deepClone () const
{
  ArrayAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


JavaArrayAccessNode *JavaArrayAccessNode::clone () const
{
  JavaArrayAccessNode* copy = new JavaArrayAccessNode(*this);
  copy->children = copy->_children; return copy;
}

JavaArrayAccessNode *JavaArrayAccessNode::deepClone () const
{
  JavaArrayAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TitaniumArrayAccessNode *TitaniumArrayAccessNode::clone () const
{
  TitaniumArrayAccessNode* copy = new TitaniumArrayAccessNode(*this);
  copy->children = copy->_children; return copy;
}

TitaniumArrayAccessNode *TitaniumArrayAccessNode::deepClone () const
{
  TitaniumArrayAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PointArrayAccessNode *PointArrayAccessNode::clone () const
{
  PointArrayAccessNode* copy = new PointArrayAccessNode(*this);
  copy->children = copy->_children; return copy;
}

PointArrayAccessNode *PointArrayAccessNode::deepClone () const
{
  PointArrayAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ObjectNode *ObjectNode::clone () const
{
  ObjectNode* copy = new ObjectNode(*this);
  copy->children = copy->_children; return copy;
}

ObjectNode *ObjectNode::deepClone () const
{
  ObjectNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ObjectFieldAccessNode *ObjectFieldAccessNode::clone () const
{
  ObjectFieldAccessNode* copy = new ObjectFieldAccessNode(*this);
  copy->children = copy->_children; return copy;
}

ObjectFieldAccessNode *ObjectFieldAccessNode::deepClone () const
{
  ObjectFieldAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TypeFieldAccessNode *TypeFieldAccessNode::clone () const
{
  TypeFieldAccessNode* copy = new TypeFieldAccessNode(*this);
  copy->children = copy->_children; return copy;
}

TypeFieldAccessNode *TypeFieldAccessNode::deepClone () const
{
  TypeFieldAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ThisFieldAccessNode *ThisFieldAccessNode::clone () const
{
  ThisFieldAccessNode* copy = new ThisFieldAccessNode(*this);
  copy->children = copy->_children; return copy;
}

ThisFieldAccessNode *ThisFieldAccessNode::deepClone () const
{
  ThisFieldAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


SuperFieldAccessNode *SuperFieldAccessNode::clone () const
{
  SuperFieldAccessNode* copy = new SuperFieldAccessNode(*this);
  copy->children = copy->_children; return copy;
}

SuperFieldAccessNode *SuperFieldAccessNode::deepClone () const
{
  SuperFieldAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MethodCallNode *MethodCallNode::clone () const
{
  MethodCallNode* copy = new MethodCallNode(*this);
  copy->children = copy->_children; return copy;
}

MethodCallNode *MethodCallNode::deepClone () const
{
  MethodCallNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MethodCallAssignNode *MethodCallAssignNode::clone () const
{
  MethodCallAssignNode* copy = new MethodCallAssignNode(*this);
  copy->children = copy->_children; return copy;
}

MethodCallAssignNode *MethodCallAssignNode::deepClone () const
{
  MethodCallAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


AllocateNode *AllocateNode::clone () const
{
  AllocateNode* copy = new AllocateNode(*this);
  copy->children = copy->_children; return copy;
}

AllocateNode *AllocateNode::deepClone () const
{
  AllocateNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


AllocateSpaceNode *AllocateSpaceNode::clone () const
{
  AllocateSpaceNode* copy = new AllocateSpaceNode(*this);
  copy->children = copy->_children; return copy;
}

AllocateSpaceNode *AllocateSpaceNode::deepClone () const
{
  AllocateSpaceNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


AllocateArrayNode *AllocateArrayNode::clone () const
{
  AllocateArrayNode* copy = new AllocateArrayNode(*this);
  copy->children = copy->_children; return copy;
}

AllocateArrayNode *AllocateArrayNode::deepClone () const
{
  AllocateArrayNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PostIncrNode *PostIncrNode::clone () const
{
  PostIncrNode* copy = new PostIncrNode(*this);
  copy->children = copy->_children; return copy;
}

PostIncrNode *PostIncrNode::deepClone () const
{
  PostIncrNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PostDecrNode *PostDecrNode::clone () const
{
  PostDecrNode* copy = new PostDecrNode(*this);
  copy->children = copy->_children; return copy;
}

PostDecrNode *PostDecrNode::deepClone () const
{
  PostDecrNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


UnaryPlusNode *UnaryPlusNode::clone () const
{
  UnaryPlusNode* copy = new UnaryPlusNode(*this);
  copy->children = copy->_children; return copy;
}

UnaryPlusNode *UnaryPlusNode::deepClone () const
{
  UnaryPlusNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


UnaryMinusNode *UnaryMinusNode::clone () const
{
  UnaryMinusNode* copy = new UnaryMinusNode(*this);
  copy->children = copy->_children; return copy;
}

UnaryMinusNode *UnaryMinusNode::deepClone () const
{
  UnaryMinusNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PreIncrNode *PreIncrNode::clone () const
{
  PreIncrNode* copy = new PreIncrNode(*this);
  copy->children = copy->_children; return copy;
}

PreIncrNode *PreIncrNode::deepClone () const
{
  PreIncrNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PreDecrNode *PreDecrNode::clone () const
{
  PreDecrNode* copy = new PreDecrNode(*this);
  copy->children = copy->_children; return copy;
}

PreDecrNode *PreDecrNode::deepClone () const
{
  PreDecrNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ComplementNode *ComplementNode::clone () const
{
  ComplementNode* copy = new ComplementNode(*this);
  copy->children = copy->_children; return copy;
}

ComplementNode *ComplementNode::deepClone () const
{
  ComplementNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


NotNode *NotNode::clone () const
{
  NotNode* copy = new NotNode(*this);
  copy->children = copy->_children; return copy;
}

NotNode *NotNode::deepClone () const
{
  NotNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CastNode *CastNode::clone () const
{
  CastNode* copy = new CastNode(*this);
  copy->children = copy->_children; return copy;
}

CastNode *CastNode::deepClone () const
{
  CastNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MultNode *MultNode::clone () const
{
  MultNode* copy = new MultNode(*this);
  copy->children = copy->_children; return copy;
}

MultNode *MultNode::deepClone () const
{
  MultNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DivNode *DivNode::clone () const
{
  DivNode* copy = new DivNode(*this);
  copy->children = copy->_children; return copy;
}

DivNode *DivNode::deepClone () const
{
  DivNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RemNode *RemNode::clone () const
{
  RemNode* copy = new RemNode(*this);
  copy->children = copy->_children; return copy;
}

RemNode *RemNode::deepClone () const
{
  RemNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PlusNode *PlusNode::clone () const
{
  PlusNode* copy = new PlusNode(*this);
  copy->children = copy->_children; return copy;
}

PlusNode *PlusNode::deepClone () const
{
  PlusNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


StringConcatNode *StringConcatNode::clone () const
{
  StringConcatNode* copy = new StringConcatNode(*this);
  copy->children = copy->_children; return copy;
}

StringConcatNode *StringConcatNode::deepClone () const
{
  StringConcatNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


StringConcatAssignNode *StringConcatAssignNode::clone () const
{
  StringConcatAssignNode* copy = new StringConcatAssignNode(*this);
  copy->children = copy->_children; return copy;
}

StringConcatAssignNode *StringConcatAssignNode::deepClone () const
{
  StringConcatAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MinusNode *MinusNode::clone () const
{
  MinusNode* copy = new MinusNode(*this);
  copy->children = copy->_children; return copy;
}

MinusNode *MinusNode::deepClone () const
{
  MinusNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LeftShiftLogNode *LeftShiftLogNode::clone () const
{
  LeftShiftLogNode* copy = new LeftShiftLogNode(*this);
  copy->children = copy->_children; return copy;
}

LeftShiftLogNode *LeftShiftLogNode::deepClone () const
{
  LeftShiftLogNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RightShiftLogNode *RightShiftLogNode::clone () const
{
  RightShiftLogNode* copy = new RightShiftLogNode(*this);
  copy->children = copy->_children; return copy;
}

RightShiftLogNode *RightShiftLogNode::deepClone () const
{
  RightShiftLogNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RightShiftArithNode *RightShiftArithNode::clone () const
{
  RightShiftArithNode* copy = new RightShiftArithNode(*this);
  copy->children = copy->_children; return copy;
}

RightShiftArithNode *RightShiftArithNode::deepClone () const
{
  RightShiftArithNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LTNode *LTNode::clone () const
{
  LTNode* copy = new LTNode(*this);
  copy->children = copy->_children; return copy;
}

LTNode *LTNode::deepClone () const
{
  LTNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


GTNode *GTNode::clone () const
{
  GTNode* copy = new GTNode(*this);
  copy->children = copy->_children; return copy;
}

GTNode *GTNode::deepClone () const
{
  GTNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LENode *LENode::clone () const
{
  LENode* copy = new LENode(*this);
  copy->children = copy->_children; return copy;
}

LENode *LENode::deepClone () const
{
  LENode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


GENode *GENode::clone () const
{
  GENode* copy = new GENode(*this);
  copy->children = copy->_children; return copy;
}

GENode *GENode::deepClone () const
{
  GENode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


InstanceOfNode *InstanceOfNode::clone () const
{
  InstanceOfNode* copy = new InstanceOfNode(*this);
  copy->children = copy->_children; return copy;
}

InstanceOfNode *InstanceOfNode::deepClone () const
{
  InstanceOfNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


EQNode *EQNode::clone () const
{
  EQNode* copy = new EQNode(*this);
  copy->children = copy->_children; return copy;
}

EQNode *EQNode::deepClone () const
{
  EQNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


NENode *NENode::clone () const
{
  NENode* copy = new NENode(*this);
  copy->children = copy->_children; return copy;
}

NENode *NENode::deepClone () const
{
  NENode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BitAndNode *BitAndNode::clone () const
{
  BitAndNode* copy = new BitAndNode(*this);
  copy->children = copy->_children; return copy;
}

BitAndNode *BitAndNode::deepClone () const
{
  BitAndNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BitOrNode *BitOrNode::clone () const
{
  BitOrNode* copy = new BitOrNode(*this);
  copy->children = copy->_children; return copy;
}

BitOrNode *BitOrNode::deepClone () const
{
  BitOrNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BitXorNode *BitXorNode::clone () const
{
  BitXorNode* copy = new BitXorNode(*this);
  copy->children = copy->_children; return copy;
}

BitXorNode *BitXorNode::deepClone () const
{
  BitXorNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CandNode *CandNode::clone () const
{
  CandNode* copy = new CandNode(*this);
  copy->children = copy->_children; return copy;
}

CandNode *CandNode::deepClone () const
{
  CandNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CorNode *CorNode::clone () const
{
  CorNode* copy = new CorNode(*this);
  copy->children = copy->_children; return copy;
}

CorNode *CorNode::deepClone () const
{
  CorNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


IfExprNode *IfExprNode::clone () const
{
  IfExprNode* copy = new IfExprNode(*this);
  copy->children = copy->_children; return copy;
}

IfExprNode *IfExprNode::deepClone () const
{
  IfExprNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


AssignNode *AssignNode::clone () const
{
  AssignNode* copy = new AssignNode(*this);
  copy->children = copy->_children; return copy;
}

AssignNode *AssignNode::deepClone () const
{
  AssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MultAssignNode *MultAssignNode::clone () const
{
  MultAssignNode* copy = new MultAssignNode(*this);
  copy->children = copy->_children; return copy;
}

MultAssignNode *MultAssignNode::deepClone () const
{
  MultAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DivAssignNode *DivAssignNode::clone () const
{
  DivAssignNode* copy = new DivAssignNode(*this);
  copy->children = copy->_children; return copy;
}

DivAssignNode *DivAssignNode::deepClone () const
{
  DivAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RemAssignNode *RemAssignNode::clone () const
{
  RemAssignNode* copy = new RemAssignNode(*this);
  copy->children = copy->_children; return copy;
}

RemAssignNode *RemAssignNode::deepClone () const
{
  RemAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PlusAssignNode *PlusAssignNode::clone () const
{
  PlusAssignNode* copy = new PlusAssignNode(*this);
  copy->children = copy->_children; return copy;
}

PlusAssignNode *PlusAssignNode::deepClone () const
{
  PlusAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MinusAssignNode *MinusAssignNode::clone () const
{
  MinusAssignNode* copy = new MinusAssignNode(*this);
  copy->children = copy->_children; return copy;
}

MinusAssignNode *MinusAssignNode::deepClone () const
{
  MinusAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LeftShiftLogAssignNode *LeftShiftLogAssignNode::clone () const
{
  LeftShiftLogAssignNode* copy = new LeftShiftLogAssignNode(*this);
  copy->children = copy->_children; return copy;
}

LeftShiftLogAssignNode *LeftShiftLogAssignNode::deepClone () const
{
  LeftShiftLogAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RightShiftLogAssignNode *RightShiftLogAssignNode::clone () const
{
  RightShiftLogAssignNode* copy = new RightShiftLogAssignNode(*this);
  copy->children = copy->_children; return copy;
}

RightShiftLogAssignNode *RightShiftLogAssignNode::deepClone () const
{
  RightShiftLogAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RightShiftArithAssignNode *RightShiftArithAssignNode::clone () const
{
  RightShiftArithAssignNode* copy = new RightShiftArithAssignNode(*this);
  copy->children = copy->_children; return copy;
}

RightShiftArithAssignNode *RightShiftArithAssignNode::deepClone () const
{
  RightShiftArithAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BitAndAssignNode *BitAndAssignNode::clone () const
{
  BitAndAssignNode* copy = new BitAndAssignNode(*this);
  copy->children = copy->_children; return copy;
}

BitAndAssignNode *BitAndAssignNode::deepClone () const
{
  BitAndAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BitXorAssignNode *BitXorAssignNode::clone () const
{
  BitXorAssignNode* copy = new BitXorAssignNode(*this);
  copy->children = copy->_children; return copy;
}

BitXorAssignNode *BitXorAssignNode::deepClone () const
{
  BitXorAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BitOrAssignNode *BitOrAssignNode::clone () const
{
  BitOrAssignNode* copy = new BitOrAssignNode(*this);
  copy->children = copy->_children; return copy;
}

BitOrAssignNode *BitOrAssignNode::deepClone () const
{
  BitOrAssignNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PointTypeNode *PointTypeNode::clone () const
{
  PointTypeNode* copy = new PointTypeNode(*this);
  copy->children = copy->_children; return copy;
}

PointTypeNode *PointTypeNode::deepClone () const
{
  PointTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


RectDomainTypeNode *RectDomainTypeNode::clone () const
{
  RectDomainTypeNode* copy = new RectDomainTypeNode(*this);
  copy->children = copy->_children; return copy;
}

RectDomainTypeNode *RectDomainTypeNode::deepClone () const
{
  RectDomainTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DomainTypeNode *DomainTypeNode::clone () const
{
  DomainTypeNode* copy = new DomainTypeNode(*this);
  copy->children = copy->_children; return copy;
}

DomainTypeNode *DomainTypeNode::deepClone () const
{
  DomainTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TitaniumArrayTypeNode *TitaniumArrayTypeNode::clone () const
{
  TitaniumArrayTypeNode* copy = new TitaniumArrayTypeNode(*this);
  copy->children = copy->_children; return copy;
}

TitaniumArrayTypeNode *TitaniumArrayTypeNode::deepClone () const
{
  TitaniumArrayTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ForEachPairNode *ForEachPairNode::clone () const
{
  ForEachPairNode* copy = new ForEachPairNode(*this);
  copy->children = copy->_children; return copy;
}

ForEachPairNode *ForEachPairNode::deepClone () const
{
  ForEachPairNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ForEachSetupNode *ForEachSetupNode::clone () const
{
  ForEachSetupNode* copy = new ForEachSetupNode(*this);
  copy->children = NULL; return copy;
}

ForEachSetupNode *ForEachSetupNode::deepClone () const
{
  ForEachSetupNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


StrippedForEachNode *StrippedForEachNode::clone () const
{
  StrippedForEachNode* copy = new StrippedForEachNode(*this);
  copy->children = copy->_children; return copy;
}

StrippedForEachNode *StrippedForEachNode::deepClone () const
{
  StrippedForEachNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


UpdatePointBeforeStmtNode *UpdatePointBeforeStmtNode::clone () const
{
  UpdatePointBeforeStmtNode* copy = new UpdatePointBeforeStmtNode(*this);
  copy->children = copy->_children; return copy;
}

UpdatePointBeforeStmtNode *UpdatePointBeforeStmtNode::deepClone () const
{
  UpdatePointBeforeStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ForEachStmtNode *ForEachStmtNode::clone () const
{
  ForEachStmtNode* copy = new ForEachStmtNode(*this);
  copy->children = copy->_children; return copy;
}

ForEachStmtNode *ForEachStmtNode::deepClone () const
{
  ForEachStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ReorderNode *ReorderNode::clone () const
{
  ReorderNode* copy = new ReorderNode(*this);
  copy->children = copy->_children; return copy;
}

ReorderNode *ReorderNode::deepClone () const
{
  ReorderNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PartitionStmtNode *PartitionStmtNode::clone () const
{
  PartitionStmtNode* copy = new PartitionStmtNode(*this);
  copy->children = copy->_children; return copy;
}

PartitionStmtNode *PartitionStmtNode::deepClone () const
{
  PartitionStmtNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PartitionClauseNode *PartitionClauseNode::clone () const
{
  PartitionClauseNode* copy = new PartitionClauseNode(*this);
  copy->children = copy->_children; return copy;
}

PartitionClauseNode *PartitionClauseNode::deepClone () const
{
  PartitionClauseNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


BroadcastNode *BroadcastNode::clone () const
{
  BroadcastNode* copy = new BroadcastNode(*this);
  copy->children = copy->_children; return copy;
}

BroadcastNode *BroadcastNode::deepClone () const
{
  BroadcastNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PointNode *PointNode::clone () const
{
  PointNode* copy = new PointNode(*this);
  copy->children = copy->_children; return copy;
}

PointNode *PointNode::deepClone () const
{
  PointNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


DomainNode *DomainNode::clone () const
{
  DomainNode* copy = new DomainNode(*this);
  copy->children = copy->_children; return copy;
}

DomainNode *DomainNode::deepClone () const
{
  DomainNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


EmptyArrayNode *EmptyArrayNode::clone () const
{
  EmptyArrayNode* copy = new EmptyArrayNode(*this);
  copy->children = NULL; return copy;
}

EmptyArrayNode *EmptyArrayNode::deepClone () const
{
  EmptyArrayNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ExpressionArrayNode *ExpressionArrayNode::clone () const
{
  ExpressionArrayNode* copy = new ExpressionArrayNode(*this);
  copy->children = copy->_children; return copy;
}

ExpressionArrayNode *ExpressionArrayNode::deepClone () const
{
  ExpressionArrayNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TitaniumArrayNode *TitaniumArrayNode::clone () const
{
  TitaniumArrayNode* copy = new TitaniumArrayNode(*this);
  copy->children = copy->_children; return copy;
}

TitaniumArrayNode *TitaniumArrayNode::deepClone () const
{
  TitaniumArrayNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


AllocateArrayDimensionNode *AllocateArrayDimensionNode::clone () const
{
  AllocateArrayDimensionNode* copy = new AllocateArrayDimensionNode(*this);
  copy->children = copy->_children; return copy;
}

AllocateArrayDimensionNode *AllocateArrayDimensionNode::deepClone () const
{
  AllocateArrayDimensionNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ArrayNameNode *ArrayNameNode::clone () const
{
  ArrayNameNode* copy = new ArrayNameNode(*this);
  copy->children = copy->_children; return copy;
}

ArrayNameNode *ArrayNameNode::deepClone () const
{
  ArrayNameNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


PragmaNode *PragmaNode::clone () const
{
  PragmaNode* copy = new PragmaNode(*this);
  copy->children = copy->_children; return copy;
}

PragmaNode *PragmaNode::deepClone () const
{
  PragmaNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


HasNoOverlapNode *HasNoOverlapNode::clone () const
{
  HasNoOverlapNode* copy = new HasNoOverlapNode(*this);
  copy->children = copy->_children; return copy;
}

HasNoOverlapNode *HasNoOverlapNode::deepClone () const
{
  HasNoOverlapNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


SRArrayAccessNode *SRArrayAccessNode::clone () const
{
  SRArrayAccessNode* copy = new SRArrayAccessNode(*this);
  copy->children = copy->_children; return copy;
}

SRArrayAccessNode *SRArrayAccessNode::deepClone () const
{
  SRArrayAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


OSRArrayAccessNode *OSRArrayAccessNode::clone () const
{
  OSRArrayAccessNode* copy = new OSRArrayAccessNode(*this);
  copy->children = copy->_children; return copy;
}

OSRArrayAccessNode *OSRArrayAccessNode::deepClone () const
{
  OSRArrayAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


IBroadcastNode *IBroadcastNode::clone () const
{
  IBroadcastNode* copy = new IBroadcastNode(*this);
  copy->children = copy->_children; return copy;
}

IBroadcastNode *IBroadcastNode::deepClone () const
{
  IBroadcastNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


StringConcatAssignPreLoweringNode *StringConcatAssignPreLoweringNode::clone () const
{
  StringConcatAssignPreLoweringNode* copy = new StringConcatAssignPreLoweringNode(*this);
  copy->children = copy->_children; return copy;
}

StringConcatAssignPreLoweringNode *StringConcatAssignPreLoweringNode::deepClone () const
{
  StringConcatAssignPreLoweringNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MethodTypeNode *MethodTypeNode::clone () const
{
  MethodTypeNode* copy = new MethodTypeNode(*this);
  copy->children = copy->_children; return copy;
}

MethodTypeNode *MethodTypeNode::deepClone () const
{
  MethodTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


NullTypeNode *NullTypeNode::clone () const
{
  NullTypeNode* copy = new NullTypeNode(*this);
  copy->children = NULL; return copy;
}

NullTypeNode *NullTypeNode::deepClone () const
{
  NullTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


ArrayInitializerTypeNode *ArrayInitializerTypeNode::clone () const
{
  ArrayInitializerTypeNode* copy = new ArrayInitializerTypeNode(*this);
  copy->children = NULL; return copy;
}

ArrayInitializerTypeNode *ArrayInitializerTypeNode::deepClone () const
{
  ArrayInitializerTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CodeLiteralNode *CodeLiteralNode::clone () const
{
  CodeLiteralNode* copy = new CodeLiteralNode(*this);
  copy->children = NULL; return copy;
}

CodeLiteralNode *CodeLiteralNode::deepClone () const
{
  CodeLiteralNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CodeLiteralExprNode *CodeLiteralExprNode::clone () const
{
  CodeLiteralExprNode* copy = new CodeLiteralExprNode(*this);
  copy->children = NULL; return copy;
}

CodeLiteralExprNode *CodeLiteralExprNode::deepClone () const
{
  CodeLiteralExprNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CodeLiteralFieldAccessNode *CodeLiteralFieldAccessNode::clone () const
{
  CodeLiteralFieldAccessNode* copy = new CodeLiteralFieldAccessNode(*this);
  copy->children = copy->_children; return copy;
}

CodeLiteralFieldAccessNode *CodeLiteralFieldAccessNode::deepClone () const
{
  CodeLiteralFieldAccessNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


LazyOptimizeNode *LazyOptimizeNode::clone () const
{
  LazyOptimizeNode* copy = new LazyOptimizeNode(*this);
  copy->children = copy->_children; return copy;
}

LazyOptimizeNode *LazyOptimizeNode::deepClone () const
{
  LazyOptimizeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MonitorFetchClassNode *MonitorFetchClassNode::clone () const
{
  MonitorFetchClassNode* copy = new MonitorFetchClassNode(*this);
  copy->children = NULL; return copy;
}

MonitorFetchClassNode *MonitorFetchClassNode::deepClone () const
{
  MonitorFetchClassNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MonitorFetchInstanceNode *MonitorFetchInstanceNode::clone () const
{
  MonitorFetchInstanceNode* copy = new MonitorFetchInstanceNode(*this);
  copy->children = copy->_children; return copy;
}

MonitorFetchInstanceNode *MonitorFetchInstanceNode::deepClone () const
{
  MonitorFetchInstanceNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MonitorLockNode *MonitorLockNode::clone () const
{
  MonitorLockNode* copy = new MonitorLockNode(*this);
  copy->children = NULL; return copy;
}

MonitorLockNode *MonitorLockNode::deepClone () const
{
  MonitorLockNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


MonitorUnlockNode *MonitorUnlockNode::clone () const
{
  MonitorUnlockNode* copy = new MonitorUnlockNode(*this);
  copy->children = NULL; return copy;
}

MonitorUnlockNode *MonitorUnlockNode::deepClone () const
{
  MonitorUnlockNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


CheckNullNode *CheckNullNode::clone () const
{
  CheckNullNode* copy = new CheckNullNode(*this);
  copy->children = copy->_children; return copy;
}

CheckNullNode *CheckNullNode::deepClone () const
{
  CheckNullNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


AssertNode *AssertNode::clone () const
{
  AssertNode* copy = new AssertNode(*this);
  copy->children = copy->_children; return copy;
}

AssertNode *AssertNode::deepClone () const
{
  AssertNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TemplateNameNode *TemplateNameNode::clone () const
{
  TemplateNameNode* copy = new TemplateNameNode(*this);
  copy->children = copy->_children; return copy;
}

TemplateNameNode *TemplateNameNode::deepClone () const
{
  TemplateNameNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TemplateInstanceTypeNode *TemplateInstanceTypeNode::clone () const
{
  TemplateInstanceTypeNode* copy = new TemplateInstanceTypeNode(*this);
  copy->children = copy->_children; return copy;
}

TemplateInstanceTypeNode *TemplateInstanceTypeNode::deepClone () const
{
  TemplateInstanceTypeNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TemplateDeclNode *TemplateDeclNode::clone () const
{
  TemplateDeclNode* copy = new TemplateDeclNode(*this);
  copy->children = copy->_children; return copy;
}

TemplateDeclNode *TemplateDeclNode::deepClone () const
{
  TemplateDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TemplateConstParamNode *TemplateConstParamNode::clone () const
{
  TemplateConstParamNode* copy = new TemplateConstParamNode(*this);
  copy->children = copy->_children; return copy;
}

TemplateConstParamNode *TemplateConstParamNode::deepClone () const
{
  TemplateConstParamNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TemplateTypeParamNode *TemplateTypeParamNode::clone () const
{
  TemplateTypeParamNode* copy = new TemplateTypeParamNode(*this);
  copy->children = copy->_children; return copy;
}

TemplateTypeParamNode *TemplateTypeParamNode::deepClone () const
{
  TemplateTypeParamNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}


TemplateInstanceDeclNode *TemplateInstanceDeclNode::clone () const
{
  TemplateInstanceDeclNode* copy = new TemplateInstanceDeclNode(*this);
  copy->children = copy->_children; return copy;
}

TemplateInstanceDeclNode *TemplateInstanceDeclNode::deepClone () const
{
  TemplateInstanceDeclNode* const copy = clone();
  deepCloneChildren(*copy);
  deepCloneSpecial(copy); 
  return copy;
}