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


#include <iostream>

#include "AST.h"
#include "code-commonsub.h"
#include "streq.h"


bool NameNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const NameNode *u;
  u = (const NameNode *) t;
  return true 
     && // fld=(qualifier TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=qualifier()
(qualifier()->absent() == u->qualifier()->absent()) && (qualifier()->absent() || COMPARE(qualifier(), u->qualifier()))
     && // fld=(ident const string* NULL)
  // nodetype=const string*, type=const string*, var=ident()
(*ident() == *u->ident())
     && // fld=(decl Decl* NULL)
  // nodetype=Decl*, type=Decl*, var=decl()
(decl() == u->decl());
}


bool PrimitiveLitNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PrimitiveLitNode *u;
  u = (const PrimitiveLitNode *) t;
  return true 
     && // fld=(literal Literal Literal((int32)0))
  // nodetype=Literal, type=Literal, var=literal()
(literal().asString() == u->literal().asString());
}


bool StringLitNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const StringLitNode *u;
  u = (const StringLitNode *) t;
  return true 
     && // fld=(text string16 string16())
  // nodetype=string16, type=string16, var=text()
(text() == u->text());
}


bool BoolTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BoolTypeNode *u;
  u = (const BoolTypeNode *) t;
  return true ;
}


bool CharTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CharTypeNode *u;
  u = (const CharTypeNode *) t;
  return true ;
}


bool ByteTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ByteTypeNode *u;
  u = (const ByteTypeNode *) t;
  return true ;
}


bool ShortTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ShortTypeNode *u;
  u = (const ShortTypeNode *) t;
  return true ;
}


bool IntTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const IntTypeNode *u;
  u = (const IntTypeNode *) t;
  return true ;
}


bool FloatTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const FloatTypeNode *u;
  u = (const FloatTypeNode *) t;
  return true ;
}


bool LongTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LongTypeNode *u;
  u = (const LongTypeNode *) t;
  return true ;
}


bool DoubleTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DoubleTypeNode *u;
  u = (const DoubleTypeNode *) t;
  return true ;
}


bool TypeNameNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TypeNameNode *u;
  u = (const TypeNameNode *) t;
  return true 
     && // fld=(name TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=name()
(name()->absent() == u->name()->absent()) && (name()->absent() || COMPARE(name(), u->name()));
}


bool JavaArrayTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const JavaArrayTypeNode *u;
  u = (const JavaArrayTypeNode *) t;
  return true 
     && // fld=(elementType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=elementType()
(elementType()->cType() == u->elementType()->cType());
}


bool CompileUnitNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CompileUnitNode *u;
  u = (const CompileUnitNode *) t;
  return true 
     && // fld=(ident const string* NULL)
  // nodetype=const string*, type=const string*, var=ident()
(*ident() == *u->ident())
     && // fld=(package TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=package()
(package()->absent() == u->package()->absent()) && (package()->absent() || COMPARE(package(), u->package()))
     && // fld=(imports TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=imports()
COMPARE(imports(), u->imports())
     && // fld=(types TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=types()
(types()->absent() == u->types()->absent()) && (types()->absent() || COMPARE(types(), u->types()))
     && // fld=(environ Environ * NULL)
  // nodetype=Environ *, type=Environ *, var=environ()
(environ() == u->environ())
     && // state=(thePackage Decl * NULL)
  // nodetype=Decl *, type=Decl *, var=thePackage
(thePackage == u->thePackage)
     && // state=(importedPackages llist<Decl *> * NULL)
  // nodetype=llist<Decl *> *, type=llist<Decl *> *, var=importedPackages
(importedPackages == u->importedPackages)
     && // state=(ranLazyStaticSemantics bool false)
  // nodetype=bool, type=bool, var=ranLazyStaticSemantics
(ranLazyStaticSemantics == u->ranLazyStaticSemantics)
     && // state=(_pragma TiPragma nil)
  // nodetype=TiPragma, type=TiPragma, var=_pragma
(_pragma == u->_pragma);
}


bool ImportNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ImportNode *u;
  u = (const ImportNode *) t;
  return true 
     && // fld=(name TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=name()
(name()->absent() == u->name()->absent()) && (name()->absent() || COMPARE(name(), u->name()));
}


bool ImportOnDemandNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ImportOnDemandNode *u;
  u = (const ImportOnDemandNode *) t;
  return true 
     && // fld=(name TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=name()
(name()->absent() == u->name()->absent()) && (name()->absent() || COMPARE(name(), u->name()));
}


bool ClassDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ClassDeclNode *u;
  u = (const ClassDeclNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(superClass TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=superClass()
(superClass()->absent() == u->superClass()->absent()) && (superClass()->absent() || COMPARE(superClass(), u->superClass()))
     && // fld=(interfaces TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=interfaces()
(interfaces() == u->interfaces())
     && // fld=(members TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=members()
COMPARE(members(), u->members())
     && // fld=(enclosingType TypeDeclNode * NULL)
  // nodetype=TypeDeclNode *, type=TypeDeclNode *, var=enclosingType()
(enclosingType() == u->enclosingType())
     && // fld=(enclosingBlock TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=enclosingBlock()
(enclosingBlock()->absent() == u->enclosingBlock()->absent()) && (enclosingBlock()->absent() || COMPARE(enclosingBlock(), u->enclosingBlock()))
     && // fld=(declaredName NameNode * NULL)
  // nodetype=NameNode *, type=NameNode *, var=declaredName()
(declaredName() == u->declaredName())
     && // fld=(hasEnclosingInstance bool false)
  // nodetype=bool, type=bool, var=hasEnclosingInstance()
(hasEnclosingInstance() == u->hasEnclosingInstance())
     && // fld=(finalVars TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=finalVars()
(finalVars()->absent() == u->finalVars()->absent()) && (finalVars()->absent() || COMPARE(finalVars(), u->finalVars()))
     && // fld=(allocateContext TreeNode::AllocateContext * NULL)
  // nodetype=TreeNode::AllocateContext *, type=TreeNode::AllocateContext *, var=allocateContext()
(allocateContext() == u->allocateContext())
     && // fld=(classNum int 0)
  // nodetype=int, type=int, var=classNum()
(classNum() == u->classNum())
     && // state=(_localCount int 0)
  // nodetype=int, type=int, var=_localCount
(_localCount == u->_localCount)
     && // state=(_anonCount int 0)
  // nodetype=int, type=int, var=_anonCount
(_anonCount == u->_anonCount);
}


bool FieldDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const FieldDeclNode *u;
  u = (const FieldDeclNode *) t;
  return true 
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(initExpr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=initExpr()
(initExpr()->absent() == u->initExpr()->absent()) && (initExpr()->absent() || COMPARE(initExpr(), u->initExpr()))
     && // state=(_compilerGeneratedInitExpr bool false)
  // nodetype=bool, type=bool, var=_compilerGeneratedInitExpr
(_compilerGeneratedInitExpr == u->_compilerGeneratedInitExpr);
}


bool VarDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const VarDeclNode *u;
  u = (const VarDeclNode *) t;
  return true 
     && // fld=(isfinal bool false)
  // nodetype=bool, type=bool, var=isfinal()
(isfinal() == u->isfinal())
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(initExpr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=initExpr()
(initExpr()->absent() == u->initExpr()->absent()) && (initExpr()->absent() || COMPARE(initExpr(), u->initExpr()))
     && // state=(_mangledIdent const string * NULL)
  // nodetype=const string *, type=const string *, var=_mangledIdent
(*_mangledIdent == *u->_mangledIdent)
     && // state=(_needsDefaultInitialization bool false)
  // nodetype=bool, type=bool, var=_needsDefaultInitialization
(_needsDefaultInitialization == u->_needsDefaultInitialization);
}


bool MethodDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MethodDeclNode *u;
  u = (const MethodDeclNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(params TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=params()
COMPARE(params(), u->params())
     && // fld=(returnType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=returnType()
(returnType()->cType() == u->returnType()->cType())
     && // fld=(declaredReturnType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=declaredReturnType()
(declaredReturnType()->cType() == u->declaredReturnType()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(throws TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=throws()
(throws() == u->throws())
     && // fld=(overlaps TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=overlaps()
COMPARE(overlaps(), u->overlaps())
     && // fld=(body TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=body()
(body()->absent() == u->body()->absent()) && (body()->absent() || COMPARE(body(), u->body()))
     && // state=(bblockRoot Bblock * NULL)
  // nodetype=Bblock *, type=Bblock *, var=bblockRoot
(bblockRoot == u->bblockRoot)
     && // state=(nodeStorage NodeStorage * NULL)
  // nodetype=NodeStorage *, type=NodeStorage *, var=nodeStorage
(nodeStorage == u->nodeStorage)
     && // state=(_methodStatics MethodStatics* NULL)
  // nodetype=MethodStatics*, type=MethodStatics*, var=_methodStatics
(_methodStatics == u->_methodStatics)
     && // state=(_inlineInfo void* NULL)
  // nodetype=void*, type=void*, var=_inlineInfo
(_inlineInfo == u->_inlineInfo);
}


bool MethodSignatureNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MethodSignatureNode *u;
  u = (const MethodSignatureNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(params TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=params()
COMPARE(params(), u->params())
     && // fld=(returnType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=returnType()
(returnType()->cType() == u->returnType()->cType())
     && // fld=(declaredReturnType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=declaredReturnType()
(declaredReturnType()->cType() == u->declaredReturnType()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(throws TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=throws()
(throws() == u->throws())
     && // state=(_methodStatics MethodStatics* NULL)
  // nodetype=MethodStatics*, type=MethodStatics*, var=_methodStatics
(_methodStatics == u->_methodStatics);
}


bool OverlapNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const OverlapNode *u;
  u = (const OverlapNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool VoidTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const VoidTypeNode *u;
  u = (const VoidTypeNode *) t;
  return true ;
}


bool ConstructorDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ConstructorDeclNode *u;
  u = (const ConstructorDeclNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(params TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=params()
COMPARE(params(), u->params())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(throws TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=throws()
(throws() == u->throws())
     && // fld=(constructorCall TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=constructorCall()
(constructorCall()->absent() == u->constructorCall()->absent()) && (constructorCall()->absent() || COMPARE(constructorCall(), u->constructorCall()))
     && // fld=(body TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=body()
(body()->absent() == u->body()->absent()) && (body()->absent() || COMPARE(body(), u->body()))
     && // fld=(initEncloser TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=initEncloser()
(initEncloser()->absent() == u->initEncloser()->absent()) && (initEncloser()->absent() || COMPARE(initEncloser(), u->initEncloser()))
     && // state=(bblockRoot Bblock * NULL)
  // nodetype=Bblock *, type=Bblock *, var=bblockRoot
(bblockRoot == u->bblockRoot)
     && // state=(nodeStorage NodeStorage * NULL)
  // nodetype=NodeStorage *, type=NodeStorage *, var=nodeStorage
(nodeStorage == u->nodeStorage)
     && // state=(_methodStatics MethodStatics* NULL)
  // nodetype=MethodStatics*, type=MethodStatics*, var=_methodStatics
(_methodStatics == u->_methodStatics)
     && // state=(_inlineInfo void* NULL)
  // nodetype=void*, type=void*, var=_inlineInfo
(_inlineInfo == u->_inlineInfo);
}


bool ThisConstructorCallNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ThisConstructorCallNode *u;
  u = (const ThisConstructorCallNode *) t;
  return true 
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args())
     && // fld=(decl Decl* NULL)
  // nodetype=Decl*, type=Decl*, var=decl()
(decl() == u->decl())
     && // fld=(valid bool true)
  // nodetype=bool, type=bool, var=valid()
(valid() == u->valid());
}


bool SuperConstructorCallNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const SuperConstructorCallNode *u;
  u = (const SuperConstructorCallNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(qualifier TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=qualifier()
(qualifier()->absent() == u->qualifier()->absent()) && (qualifier()->absent() || COMPARE(qualifier(), u->qualifier()))
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args())
     && // fld=(decl Decl* NULL)
  // nodetype=Decl*, type=Decl*, var=decl()
(decl() == u->decl());
}


bool StaticInitNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const StaticInitNode *u;
  u = (const StaticInitNode *) t;
  return true 
     && // fld=(block TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=block()
(block()->absent() == u->block()->absent()) && (block()->absent() || COMPARE(block(), u->block()));
}


bool InstanceInitNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const InstanceInitNode *u;
  u = (const InstanceInitNode *) t;
  return true 
     && // fld=(block TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=block()
(block()->absent() == u->block()->absent()) && (block()->absent() || COMPARE(block(), u->block()));
}


bool InterfaceDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const InterfaceDeclNode *u;
  u = (const InterfaceDeclNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(interfaces TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=interfaces()
(interfaces() == u->interfaces())
     && // fld=(members TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=members()
COMPARE(members(), u->members())
     && // fld=(enclosingType TypeDeclNode * NULL)
  // nodetype=TypeDeclNode *, type=TypeDeclNode *, var=enclosingType()
(enclosingType() == u->enclosingType())
     && // fld=(declaredName NameNode * NULL)
  // nodetype=NameNode *, type=NameNode *, var=declaredName()
(declaredName() == u->declaredName())
     && // fld=(hasEnclosingInstance bool false)
  // nodetype=bool, type=bool, var=hasEnclosingInstance()
(hasEnclosingInstance() == u->hasEnclosingInstance())
     && // state=(_localCount int 0)
  // nodetype=int, type=int, var=_localCount
(_localCount == u->_localCount)
     && // state=(_anonCount int 0)
  // nodetype=int, type=int, var=_anonCount
(_anonCount == u->_anonCount);
}


bool ArrayInitNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ArrayInitNode *u;
  u = (const ArrayInitNode *) t;
  return true 
     && // fld=(initializers TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=initializers()
COMPARE(initializers(), u->initializers());
}


bool BlockNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BlockNode *u;
  u = (const BlockNode *) t;
  return true 
     && // fld=(stmts TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=stmts()
COMPARE(stmts(), u->stmts())
     && // fld=(environ Environ * NULL)
  // nodetype=Environ *, type=Environ *, var=environ()
(environ() == u->environ())
     && // state=(_declContainer bool false)
  // nodetype=bool, type=bool, var=_declContainer
(_declContainer == u->_declContainer)
     && // state=(_blockContext CodeContext * NULL)
  // nodetype=CodeContext *, type=CodeContext *, var=_blockContext
(_blockContext == u->_blockContext);
}


bool EmptyStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const EmptyStmtNode *u;
  u = (const EmptyStmtNode *) t;
  return true ;
}


bool GotoNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const GotoNode *u;
  u = (const GotoNode *) t;
  return true 
     && // fld=(destination TreeNode NULL)
  // nodetype=TreeNode*, type=TreeNode *, var=destination()
(destination()->absent() == u->destination()->absent()) && (destination()->absent() || COMPARE(destination(), u->destination()));
}


bool LabeledStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LabeledStmtNode *u;
  u = (const LabeledStmtNode *) t;
  return true 
     && // fld=(label TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=label()
(label()->absent() == u->label()->absent()) && (label()->absent() || COMPARE(label(), u->label()))
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()));
}


bool IfStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const IfStmtNode *u;
  u = (const IfStmtNode *) t;
  return true 
     && // fld=(condition TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=condition()
(condition()->absent() == u->condition()->absent()) && (condition()->absent() || COMPARE(condition(), u->condition()))
     && // fld=(thenPart TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=thenPart()
(thenPart()->absent() == u->thenPart()->absent()) && (thenPart()->absent() || COMPARE(thenPart(), u->thenPart()))
     && // fld=(elsePart TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=elsePart()
(elsePart()->absent() == u->elsePart()->absent()) && (elsePart()->absent() || COMPARE(elsePart(), u->elsePart()));
}


bool SwitchNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const SwitchNode *u;
  u = (const SwitchNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(switchBlocks TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=switchBlocks()
COMPARE(switchBlocks(), u->switchBlocks());
}


bool CaseNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CaseNode *u;
  u = (const CaseNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool SwitchBranchNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const SwitchBranchNode *u;
  u = (const SwitchBranchNode *) t;
  return true 
     && // fld=(cases TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=cases()
COMPARE(cases(), u->cases())
     && // fld=(stmts TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=stmts()
COMPARE(stmts(), u->stmts());
}


bool WhileNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const WhileNode *u;
  u = (const WhileNode *) t;
  return true 
     && // fld=(test TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=test()
(test()->absent() == u->test()->absent()) && (test()->absent() || COMPARE(test(), u->test()))
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()));
}


bool DoNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DoNode *u;
  u = (const DoNode *) t;
  return true 
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()))
     && // fld=(test TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=test()
(test()->absent() == u->test()->absent()) && (test()->absent() || COMPARE(test(), u->test()));
}


bool ForNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ForNode *u;
  u = (const ForNode *) t;
  return true 
     && // fld=(init TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=init()
COMPARE(init(), u->init())
     && // fld=(test TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=test()
(test()->absent() == u->test()->absent()) && (test()->absent() || COMPARE(test(), u->test()))
     && // fld=(update TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=update()
COMPARE(update(), u->update())
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()));
}


bool BreakNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BreakNode *u;
  u = (const BreakNode *) t;
  return true 
     && // fld=(label TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=label()
(label()->absent() == u->label()->absent()) && (label()->absent() || COMPARE(label(), u->label()))
     && // fld=(destination TreeNode NULL)
  // nodetype=TreeNode*, type=TreeNode *, var=destination()
(destination()->absent() == u->destination()->absent()) && (destination()->absent() || COMPARE(destination(), u->destination()))
     && // fld=(cleanups llist<TreeNode *> * NULL)
  // nodetype=llist<TreeNode *> *, type=llist<TreeNode *> *, var=cleanups()
compareLists(cleanups(), u->cleanups());
}


bool ContinueNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ContinueNode *u;
  u = (const ContinueNode *) t;
  return true 
     && // fld=(label TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=label()
(label()->absent() == u->label()->absent()) && (label()->absent() || COMPARE(label(), u->label()))
     && // fld=(destination TreeNode NULL)
  // nodetype=TreeNode*, type=TreeNode *, var=destination()
(destination()->absent() == u->destination()->absent()) && (destination()->absent() || COMPARE(destination(), u->destination()))
     && // fld=(cleanups llist<TreeNode *> * NULL)
  // nodetype=llist<TreeNode *> *, type=llist<TreeNode *> *, var=cleanups()
compareLists(cleanups(), u->cleanups());
}


bool ReturnNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ReturnNode *u;
  u = (const ReturnNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(cleanups llist<TreeNode *> * NULL)
  // nodetype=llist<TreeNode *> *, type=llist<TreeNode *> *, var=cleanups()
compareLists(cleanups(), u->cleanups());
}


bool ThrowNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ThrowNode *u;
  u = (const ThrowNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool SynchronizedNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const SynchronizedNode *u;
  u = (const SynchronizedNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()));
}


bool CatchNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CatchNode *u;
  u = (const CatchNode *) t;
  return true 
     && // fld=(param TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=param()
(param()->absent() == u->param()->absent()) && (param()->absent() || COMPARE(param(), u->param()))
     && // fld=(block TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=block()
(block()->absent() == u->block()->absent()) && (block()->absent() || COMPARE(block(), u->block()));
}


bool TryNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TryNode *u;
  u = (const TryNode *) t;
  return true 
     && // fld=(block TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=block()
(block()->absent() == u->block()->absent()) && (block()->absent() || COMPARE(block(), u->block()));
}


bool FinallyNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const FinallyNode *u;
  u = (const FinallyNode *) t;
  return true 
     && // fld=(block TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=block()
(block()->absent() == u->block()->absent()) && (block()->absent() || COMPARE(block(), u->block()));
}


bool TryStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TryStmtNode *u;
  u = (const TryStmtNode *) t;
  return true 
     && // fld=(block TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=block()
(block()->absent() == u->block()->absent()) && (block()->absent() || COMPARE(block(), u->block()))
     && // fld=(catches CatchListNode)
  // nodetype=CatchListNode*, type=llist<CatchNode*> *, var=catches()
(catches() == u->catches())
     && // fld=(finally TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=finally()
(finally()->absent() == u->finally()->absent()) && (finally()->absent() || COMPARE(finally(), u->finally()))
     && // state=(_cfgCatch CfgNode * nil)
  // nodetype=CfgNode *, type=CfgNode *, var=_cfgCatch
(_cfgCatch == u->_cfgCatch)
     && // state=(_cfgFinally CfgNode * nil)
  // nodetype=CfgNode *, type=CfgNode *, var=_cfgFinally
(_cfgFinally == u->_cfgFinally);
}


bool ExpressionStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ExpressionStmtNode *u;
  u = (const ExpressionStmtNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool DummyNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DummyNode *u;
  u = (const DummyNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool ParameterNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ParameterNode *u;
  u = (const ParameterNode *) t;
  return true 
     && // fld=(isfinal bool false)
  // nodetype=bool, type=bool, var=isfinal()
(isfinal() == u->isfinal())
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()));
}


bool NullPntrNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const NullPntrNode *u;
  u = (const NullPntrNode *) t;
  return true ;
}


bool ThisNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ThisNode *u;
  u = (const ThisNode *) t;
  return true 
     && // fld=(qualifier TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=qualifier()
(qualifier()->absent() == u->qualifier()->absent()) && (qualifier()->absent() || COMPARE(qualifier(), u->qualifier()))
     && // fld=(theClass TreeNode NULL)
  // nodetype=TreeNode*, type=TreeNode *, var=theClass()
(theClass()->absent() == u->theClass()->absent()) && (theClass()->absent() || COMPARE(theClass(), u->theClass()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags());
}


bool ArrayAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ArrayAccessNode *u;
  u = (const ArrayAccessNode *) t;
  return true 
     && // fld=(array TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=array()
(array()->absent() == u->array()->absent()) && (array()->absent() || COMPARE(array(), u->array()))
     && // fld=(index TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=index()
(index()->absent() == u->index()->absent()) && (index()->absent() || COMPARE(index(), u->index()));
}


bool JavaArrayAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const JavaArrayAccessNode *u;
  u = (const JavaArrayAccessNode *) t;
  return true 
     && // fld=(array TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=array()
(array()->absent() == u->array()->absent()) && (array()->absent() || COMPARE(array(), u->array()))
     && // fld=(index TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=index()
(index()->absent() == u->index()->absent()) && (index()->absent() || COMPARE(index(), u->index()));
}


bool TitaniumArrayAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TitaniumArrayAccessNode *u;
  u = (const TitaniumArrayAccessNode *) t;
  return true 
     && // fld=(array TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=array()
(array()->absent() == u->array()->absent()) && (array()->absent() || COMPARE(array(), u->array()))
     && // fld=(index TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=index()
(index()->absent() == u->index()->absent()) && (index()->absent() || COMPARE(index(), u->index()));
}


bool PointArrayAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PointArrayAccessNode *u;
  u = (const PointArrayAccessNode *) t;
  return true 
     && // fld=(array TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=array()
(array()->absent() == u->array()->absent()) && (array()->absent() || COMPARE(array(), u->array()))
     && // fld=(index TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=index()
(index()->absent() == u->index()->absent()) && (index()->absent() || COMPARE(index(), u->index()));
}


bool ObjectNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ObjectNode *u;
  u = (const ObjectNode *) t;
  return true 
     && // fld=(name TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=name()
(name()->absent() == u->name()->absent()) && (name()->absent() || COMPARE(name(), u->name()));
}


bool ObjectFieldAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ObjectFieldAccessNode *u;
  u = (const ObjectFieldAccessNode *) t;
  return true 
     && // fld=(object TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=object()
(object()->absent() == u->object()->absent()) && (object()->absent() || COMPARE(object(), u->object()))
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // state=(_isRewrittenSFAN bool false)
  // nodetype=bool, type=bool, var=_isRewrittenSFAN
(_isRewrittenSFAN == u->_isRewrittenSFAN)
     && // state=(_isRewrittenQSFAN bool false)
  // nodetype=bool, type=bool, var=_isRewrittenQSFAN
(_isRewrittenQSFAN == u->_isRewrittenQSFAN);
}


bool TypeFieldAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TypeFieldAccessNode *u;
  u = (const TypeFieldAccessNode *) t;
  return true 
     && // fld=(ftype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=ftype()
(ftype()->cType() == u->ftype()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()));
}


bool ThisFieldAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ThisFieldAccessNode *u;
  u = (const ThisFieldAccessNode *) t;
  return true 
     && // fld=(theClass TreeNode NULL)
  // nodetype=TreeNode*, type=TreeNode *, var=theClass()
(theClass()->absent() == u->theClass()->absent()) && (theClass()->absent() || COMPARE(theClass(), u->theClass()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()));
}


bool SuperFieldAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const SuperFieldAccessNode *u;
  u = (const SuperFieldAccessNode *) t;
  return true 
     && // fld=(qualifier TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=qualifier()
(qualifier()->absent() == u->qualifier()->absent()) && (qualifier()->absent() || COMPARE(qualifier(), u->qualifier()))
     && // fld=(theClass TreeNode NULL)
  // nodetype=TreeNode*, type=TreeNode *, var=theClass()
(theClass()->absent() == u->theClass()->absent()) && (theClass()->absent() || COMPARE(theClass(), u->theClass()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()));
}


bool MethodCallNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MethodCallNode *u;
  u = (const MethodCallNode *) t;
  return true 
     && // fld=(method TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=method()
(method()->absent() == u->method()->absent()) && (method()->absent() || COMPARE(method(), u->method()))
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args())
     && // state=(_modifiesValues Bitset* NULL)
  // nodetype=Bitset*, type=Bitset*, var=_modifiesValues
(_modifiesValues == u->_modifiesValues)
     && // state=(_isRewrittenRHSOpOverload bool false)
  // nodetype=bool, type=bool, var=_isRewrittenRHSOpOverload
(_isRewrittenRHSOpOverload == u->_isRewrittenRHSOpOverload);
}


bool MethodCallAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MethodCallAssignNode *u;
  u = (const MethodCallAssignNode *) t;
  return true 
     && // fld=(method TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=method()
(method()->absent() == u->method()->absent()) && (method()->absent() || COMPARE(method(), u->method()))
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args())
     && // state=(_isRewrittenRHSOpOverload bool false)
  // nodetype=bool, type=bool, var=_isRewrittenRHSOpOverload
(_isRewrittenRHSOpOverload == u->_isRewrittenRHSOpOverload);
}


bool AllocateNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const AllocateNode *u;
  u = (const AllocateNode *) t;
  return true 
     && // fld=(region TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=region()
(region()->absent() == u->region()->absent()) && (region()->absent() || COMPARE(region(), u->region()))
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args())
     && // fld=(decl Decl* NULL)
  // nodetype=Decl*, type=Decl*, var=decl()
(decl() == u->decl())
     && // fld=(qualifier TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=qualifier()
(qualifier()->absent() == u->qualifier()->absent()) && (qualifier()->absent() || COMPARE(qualifier(), u->qualifier()))
     && // fld=(cbody TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=cbody()
(cbody()->absent() == u->cbody()->absent()) && (cbody()->absent() || COMPARE(cbody(), u->cbody()))
     && // state=(_modifiesValues Bitset* NULL)
  // nodetype=Bitset*, type=Bitset*, var=_modifiesValues
(_modifiesValues == u->_modifiesValues)
     && // state=(_fieldResolutions int 0)
  // nodetype=int, type=int, var=_fieldResolutions
(_fieldResolutions == u->_fieldResolutions);
}


bool AllocateSpaceNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const AllocateSpaceNode *u;
  u = (const AllocateSpaceNode *) t;
  return true 
     && // fld=(region TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=region()
(region()->absent() == u->region()->absent()) && (region()->absent() || COMPARE(region(), u->region()))
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType());
}


bool AllocateArrayNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const AllocateArrayNode *u;
  u = (const AllocateArrayNode *) t;
  return true 
     && // fld=(region TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=region()
(region()->absent() == u->region()->absent()) && (region()->absent() || COMPARE(region(), u->region()))
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(dimExprs TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=dimExprs()
COMPARE(dimExprs(), u->dimExprs())
     && // fld=(initExpr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=initExpr()
(initExpr()->absent() == u->initExpr()->absent()) && (initExpr()->absent() || COMPARE(initExpr(), u->initExpr()));
}


bool PostIncrNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PostIncrNode *u;
  u = (const PostIncrNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool PostDecrNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PostDecrNode *u;
  u = (const PostDecrNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool UnaryPlusNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const UnaryPlusNode *u;
  u = (const UnaryPlusNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool UnaryMinusNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const UnaryMinusNode *u;
  u = (const UnaryMinusNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool PreIncrNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PreIncrNode *u;
  u = (const PreIncrNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool PreDecrNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PreDecrNode *u;
  u = (const PreDecrNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool ComplementNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ComplementNode *u;
  u = (const ComplementNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool NotNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const NotNode *u;
  u = (const NotNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool CastNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CastNode *u;
  u = (const CastNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType());
}


bool MultNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MultNode *u;
  u = (const MultNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool DivNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DivNode *u;
  u = (const DivNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool RemNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RemNode *u;
  u = (const RemNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool PlusNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PlusNode *u;
  u = (const PlusNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool StringConcatNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const StringConcatNode *u;
  u = (const StringConcatNode *) t;
  return true 
     && // fld=(addends TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=addends()
COMPARE(addends(), u->addends());
}


bool StringConcatAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const StringConcatAssignNode *u;
  u = (const StringConcatAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(addends TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=addends()
COMPARE(addends(), u->addends());
}


bool MinusNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MinusNode *u;
  u = (const MinusNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool LeftShiftLogNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LeftShiftLogNode *u;
  u = (const LeftShiftLogNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool RightShiftLogNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RightShiftLogNode *u;
  u = (const RightShiftLogNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool RightShiftArithNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RightShiftArithNode *u;
  u = (const RightShiftArithNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool LTNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LTNode *u;
  u = (const LTNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool GTNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const GTNode *u;
  u = (const GTNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool LENode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LENode *u;
  u = (const LENode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool GENode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const GENode *u;
  u = (const GENode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool InstanceOfNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const InstanceOfNode *u;
  u = (const InstanceOfNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType());
}


bool EQNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const EQNode *u;
  u = (const EQNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool NENode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const NENode *u;
  u = (const NENode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool BitAndNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BitAndNode *u;
  u = (const BitAndNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool BitOrNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BitOrNode *u;
  u = (const BitOrNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool BitXorNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BitXorNode *u;
  u = (const BitXorNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool CandNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CandNode *u;
  u = (const CandNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool CorNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CorNode *u;
  u = (const CorNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool IfExprNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const IfExprNode *u;
  u = (const IfExprNode *) t;
  return true 
     && // fld=(condition TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=condition()
(condition()->absent() == u->condition()->absent()) && (condition()->absent() || COMPARE(condition(), u->condition()))
     && // fld=(thenOpnd TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=thenOpnd()
(thenOpnd()->absent() == u->thenOpnd()->absent()) && (thenOpnd()->absent() || COMPARE(thenOpnd(), u->thenOpnd()))
     && // fld=(elseOpnd TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=elseOpnd()
(elseOpnd()->absent() == u->elseOpnd()->absent()) && (elseOpnd()->absent() || COMPARE(elseOpnd(), u->elseOpnd()));
}


bool AssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const AssignNode *u;
  u = (const AssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool MultAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MultAssignNode *u;
  u = (const MultAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool DivAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DivAssignNode *u;
  u = (const DivAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool RemAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RemAssignNode *u;
  u = (const RemAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool PlusAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PlusAssignNode *u;
  u = (const PlusAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool MinusAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MinusAssignNode *u;
  u = (const MinusAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool LeftShiftLogAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LeftShiftLogAssignNode *u;
  u = (const LeftShiftLogAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool RightShiftLogAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RightShiftLogAssignNode *u;
  u = (const RightShiftLogAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool RightShiftArithAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RightShiftArithAssignNode *u;
  u = (const RightShiftArithAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool BitAndAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BitAndAssignNode *u;
  u = (const BitAndAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool BitXorAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BitXorAssignNode *u;
  u = (const BitXorAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool BitOrAssignNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BitOrAssignNode *u;
  u = (const BitOrAssignNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool PointTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PointTypeNode *u;
  u = (const PointTypeNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool RectDomainTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const RectDomainTypeNode *u;
  u = (const RectDomainTypeNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool DomainTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DomainTypeNode *u;
  u = (const DomainTypeNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool TitaniumArrayTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TitaniumArrayTypeNode *u;
  u = (const TitaniumArrayTypeNode *) t;
  return true 
     && // fld=(elementType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=elementType()
(elementType()->cType() == u->elementType()->cType())
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool ForEachPairNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ForEachPairNode *u;
  u = (const ForEachPairNode *) t;
  return true 
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(initExpr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=initExpr()
(initExpr()->absent() == u->initExpr()->absent()) && (initExpr()->absent() || COMPARE(initExpr(), u->initExpr()))
     && // fld=(dtypeopt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=dtypeopt()
(dtypeopt()->absent() == u->dtypeopt()->absent()) && (dtypeopt()->absent() || COMPARE(dtypeopt(), u->dtypeopt()));
}


bool ForEachSetupNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ForEachSetupNode *u;
  u = (const ForEachSetupNode *) t;
  return true 
     && // fld=(WRTloop TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=WRTloop()
(WRTloop()->absent() == u->WRTloop()->absent()) && (WRTloop()->absent() || COMPARE(WRTloop(), u->WRTloop()));
}


bool StrippedForEachNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const StrippedForEachNode *u;
  u = (const StrippedForEachNode *) t;
  return true 
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()));
}


bool UpdatePointBeforeStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const UpdatePointBeforeStmtNode *u;
  u = (const UpdatePointBeforeStmtNode *) t;
  return true 
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()))
     && // fld=(pointValues string ** NULL)
  // nodetype=string **, type=string **, var=pointValues()
(*pointValues() == *u->pointValues())
     && // fld=(rfrs llist< pair<TreeNode *, TreeNode *> > *  NULL)
  // nodetype=llist< pair<TreeNode *, TreeNode *> > *, type=llist< pair<TreeNode *, TreeNode *> > *, var=rfrs()
compareLists(rfrs(), u->rfrs())
     && // fld=(sirs llist< pair<TreeNode *, TreeNode *> > *  NULL)
  // nodetype=llist< pair<TreeNode *, TreeNode *> > *, type=llist< pair<TreeNode *, TreeNode *> > *, var=sirs()
compareLists(sirs(), u->sirs())
     && // fld=(urs llist< pair<TreeNode *, TreeNode *> > *  NULL)
  // nodetype=llist< pair<TreeNode *, TreeNode *> > *, type=llist< pair<TreeNode *, TreeNode *> > *, var=urs()
compareLists(urs(), u->urs())
     && // fld=(WRTloop TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=WRTloop()
(WRTloop()->absent() == u->WRTloop()->absent()) && (WRTloop()->absent() || COMPARE(WRTloop(), u->WRTloop()))
     && // state=(_valuesAreDeltas bool false)
  // nodetype=bool, type=bool, var=_valuesAreDeltas
(_valuesAreDeltas == u->_valuesAreDeltas);
}


bool ForEachStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ForEachStmtNode *u;
  u = (const ForEachStmtNode *) t;
  return true 
     && // fld=(vars TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=vars()
COMPARE(vars(), u->vars())
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()))
     && // fld=(isinline bool false)
  // nodetype=bool, type=bool, var=isinline()
(isinline() == u->isinline())
     && // state=(_defs Defs * NULL)
  // nodetype=Defs *, type=Defs *, var=_defs
(_defs == u->_defs)
     && // state=(_needPoint bool false)
  // nodetype=bool, type=bool, var=_needPoint
(_needPoint == u->_needPoint)
     && // state=(_numLifted int 0)
  // nodetype=int, type=int, var=_numLifted
(_numLifted == u->_numLifted)
     && // state=(_lo ExprNode * NULL)
  // nodetype=ExprNode *, type=ExprNode *, var=_lo
(_lo == u->_lo)
     && // state=(_hi ExprNode * NULL)
  // nodetype=ExprNode *, type=ExprNode *, var=_hi
(_hi == u->_hi)
     && // state=(_stride ExprNode * NULL)
  // nodetype=ExprNode *, type=ExprNode *, var=_stride
(_stride == u->_stride)
     && // state=(_ordered bool false)
  // nodetype=bool, type=bool, var=_ordered
(_ordered == u->_ordered)
     && // state=(_tentative bool false)
  // nodetype=bool, type=bool, var=_tentative
(_tentative == u->_tentative)
     && // state=(_parallel bool false)
  // nodetype=bool, type=bool, var=_parallel
(_parallel == u->_parallel)
     && // state=(_junk_pre llist<TreeNode *> * NULL)
  // nodetype=llist<TreeNode *> *, type=llist<TreeNode *> *, var=_junk_pre
compareLists(_junk_pre, u->_junk_pre)
     && // state=(_junk_post llist<TreeNode *> * NULL)
  // nodetype=llist<TreeNode *> *, type=llist<TreeNode *> *, var=_junk_post
compareLists(_junk_post, u->_junk_post)
     && // state=(_lifted_invariants treeSet * NULL)
  // nodetype=treeSet *, type=treeSet *, var=_lifted_invariants
(_lifted_invariants == u->_lifted_invariants)
     && // state=(_invariants treeSet * NULL)
  // nodetype=treeSet *, type=treeSet *, var=_invariants
(_invariants == u->_invariants)
     && // state=(_saveSRinfo bool false)
  // nodetype=bool, type=bool, var=_saveSRinfo
(_saveSRinfo == u->_saveSRinfo)
     && // state=(_shouldDeclare bool true)
  // nodetype=bool, type=bool, var=_shouldDeclare
(_shouldDeclare == u->_shouldDeclare)
     && // state=(_blockContext CodeContext * NULL)
  // nodetype=CodeContext *, type=CodeContext *, var=_blockContext
(_blockContext == u->_blockContext)
     && // state=(_cannotBeEmpty TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=_cannotBeEmpty
(_cannotBeEmpty->absent() == u->_cannotBeEmpty->absent()) && (_cannotBeEmpty->absent() || COMPARE(_cannotBeEmpty, u->_cannotBeEmpty))
     && // state=(arrayAccesses ArrayAccessSet * NULL)
  // nodetype=ArrayAccessSet *, type=ArrayAccessSet *, var=arrayAccesses
(arrayAccesses == u->arrayAccesses)
     && // state=(SR map_tree_to_cMIVElist * NULL)
  // nodetype=map_tree_to_cMIVElist *, type=map_tree_to_cMIVElist *, var=SR
(SR == u->SR)
     && // state=(_partialDomain bool false)
  // nodetype=bool, type=bool, var=_partialDomain
(_partialDomain == u->_partialDomain);
}


bool ReorderNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ReorderNode *u;
  u = (const ReorderNode *) t;
  return true 
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()))
     && // fld=(stmtsToDelete set<StatementNode *> * NULL)
  // nodetype=set<StatementNode *> *, type=set<StatementNode *> *, var=stmtsToDelete()
(stmtsToDelete() == u->stmtsToDelete())
     && // fld=(declsToDelete treeSet * NULL)
  // nodetype=treeSet *, type=treeSet *, var=declsToDelete()
(declsToDelete() == u->declsToDelete())
     && // fld=(remap map<TreeNode *, TreeNode *> * NULL)
  // nodetype=map<TreeNode *, TreeNode *> *, type=map<TreeNode *, TreeNode *> *, var=remap()
(remap() == u->remap());
}


bool PartitionStmtNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PartitionStmtNode *u;
  u = (const PartitionStmtNode *) t;
  return true 
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()))
     && // fld=(cases TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=cases()
COMPARE(cases(), u->cases());
}


bool PartitionClauseNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PartitionClauseNode *u;
  u = (const PartitionClauseNode *) t;
  return true 
     && // fld=(condition TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=condition()
(condition()->absent() == u->condition()->absent()) && (condition()->absent() || COMPARE(condition(), u->condition()))
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()));
}


bool BroadcastNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const BroadcastNode *u;
  u = (const BroadcastNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(proc TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=proc()
(proc()->absent() == u->proc()->absent()) && (proc()->absent() || COMPARE(proc(), u->proc()));
}


bool PointNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PointNode *u;
  u = (const PointNode *) t;
  return true 
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args());
}


bool DomainNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const DomainNode *u;
  u = (const DomainNode *) t;
  return true 
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args());
}


bool EmptyArrayNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const EmptyArrayNode *u;
  u = (const EmptyArrayNode *) t;
  return true 
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags());
}


bool ExpressionArrayNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ExpressionArrayNode *u;
  u = (const ExpressionArrayNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags());
}


bool TitaniumArrayNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TitaniumArrayNode *u;
  u = (const TitaniumArrayNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags());
}


bool AllocateArrayDimensionNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const AllocateArrayDimensionNode *u;
  u = (const AllocateArrayDimensionNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags());
}


bool ArrayNameNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ArrayNameNode *u;
  u = (const ArrayNameNode *) t;
  return true 
     && // fld=(name TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=name()
(name()->absent() == u->name()->absent()) && (name()->absent() || COMPARE(name(), u->name()))
     && // fld=(flags Common::Modifiers (Common::Modifiers)0)
  // nodetype=Common::Modifiers, type=Common::Modifiers, var=flags()
(flags() == u->flags())
     && // fld=(arrayspecifiers TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=arrayspecifiers()
COMPARE(arrayspecifiers(), u->arrayspecifiers());
}


bool PragmaNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const PragmaNode *u;
  u = (const PragmaNode *) t;
  return true 
     && // fld=(stmt TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=stmt()
(stmt()->absent() == u->stmt()->absent()) && (stmt()->absent() || COMPARE(stmt(), u->stmt()))
     && // fld=(requests Pragma::Request (Pragma::Request) 0)
  // nodetype=Pragma::Request, type=Pragma::Request, var=requests()
(requests() == u->requests());
}


bool HasNoOverlapNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const HasNoOverlapNode *u;
  u = (const HasNoOverlapNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(opnd1 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd1()
(opnd1()->absent() == u->opnd1()->absent()) && (opnd1()->absent() || COMPARE(opnd1(), u->opnd1()));
}


bool SRArrayAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const SRArrayAccessNode *u;
  u = (const SRArrayAccessNode *) t;
  return true 
     && // fld=(array TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=array()
(array()->absent() == u->array()->absent()) && (array()->absent() || COMPARE(array(), u->array()))
     && // fld=(index TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=index()
(index()->absent() == u->index()->absent()) && (index()->absent() || COMPARE(index(), u->index()))
     && // fld=(WRTloop TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=WRTloop()
(WRTloop()->absent() == u->WRTloop()->absent()) && (WRTloop()->absent() || COMPARE(WRTloop(), u->WRTloop()))
     && // fld=(codeString string "")
  // nodetype=string, type=string, var=codeString()
(codeString() == u->codeString())
     && // fld=(appearsOnEveryIter bool false)
  // nodetype=bool, type=bool, var=appearsOnEveryIter()
(appearsOnEveryIter() == u->appearsOnEveryIter());
}


bool OSRArrayAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const OSRArrayAccessNode *u;
  u = (const OSRArrayAccessNode *) t;
  return true 
     && // fld=(array TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=array()
(array()->absent() == u->array()->absent()) && (array()->absent() || COMPARE(array(), u->array()))
     && // fld=(index TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=index()
(index()->absent() == u->index()->absent()) && (index()->absent() || COMPARE(index(), u->index()))
     && // fld=(WRTloop TreeNode * NULL)
  // nodetype=TreeNode *, type=TreeNode *, var=WRTloop()
(WRTloop()->absent() == u->WRTloop()->absent()) && (WRTloop()->absent() || COMPARE(WRTloop(), u->WRTloop()))
     && // fld=(codeString string "")
  // nodetype=string, type=string, var=codeString()
(codeString() == u->codeString())
     && // fld=(offsetString string "")
  // nodetype=string, type=string, var=offsetString()
(offsetString() == u->offsetString())
     && // fld=(appearsOnEveryIter bool false)
  // nodetype=bool, type=bool, var=appearsOnEveryIter()
(appearsOnEveryIter() == u->appearsOnEveryIter());
}


bool IBroadcastNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const IBroadcastNode *u;
  u = (const IBroadcastNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()))
     && // fld=(proc TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=proc()
(proc()->absent() == u->proc()->absent()) && (proc()->absent() || COMPARE(proc(), u->proc()));
}


bool StringConcatAssignPreLoweringNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const StringConcatAssignPreLoweringNode *u;
  u = (const StringConcatAssignPreLoweringNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()));
}


bool MethodTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MethodTypeNode *u;
  u = (const MethodTypeNode *) t;
  return true 
     && // fld=(paramTypes TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=paramTypes()
(paramTypes() == u->paramTypes())
     && // fld=(returnType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=returnType()
(returnType()->cType() == u->returnType()->cType())
     && // fld=(declaredReturnType TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=declaredReturnType()
(declaredReturnType()->cType() == u->declaredReturnType()->cType())
     && // fld=(throws TypeListNode)
  // nodetype=TypeListNode*, type=llist<TypeNode*> *, var=throws()
(throws() == u->throws());
}


bool NullTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const NullTypeNode *u;
  u = (const NullTypeNode *) t;
  return true ;
}


bool ArrayInitializerTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const ArrayInitializerTypeNode *u;
  u = (const ArrayInitializerTypeNode *) t;
  return true ;
}


bool CodeLiteralNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CodeLiteralNode *u;
  u = (const CodeLiteralNode *) t;
  return true 
     && // fld=(codeString string "")
  // nodetype=string, type=string, var=codeString()
(codeString() == u->codeString());
}


bool CodeLiteralExprNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CodeLiteralExprNode *u;
  u = (const CodeLiteralExprNode *) t;
  return true 
     && // fld=(codeString string "")
  // nodetype=string, type=string, var=codeString()
(codeString() == u->codeString());
}


bool CodeLiteralFieldAccessNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CodeLiteralFieldAccessNode *u;
  u = (const CodeLiteralFieldAccessNode *) t;
  return true 
     && // fld=(opnd0 TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=opnd0()
(opnd0()->absent() == u->opnd0()->absent()) && (opnd0()->absent() || COMPARE(opnd0(), u->opnd0()))
     && // fld=(codeString string "")
  // nodetype=string, type=string, var=codeString()
(codeString() == u->codeString());
}


bool LazyOptimizeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const LazyOptimizeNode *u;
  u = (const LazyOptimizeNode *) t;
  return true 
     && // fld=(body TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=body()
(body()->absent() == u->body()->absent()) && (body()->absent() || COMPARE(body(), u->body()));
}


bool MonitorFetchClassNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MonitorFetchClassNode *u;
  u = (const MonitorFetchClassNode *) t;
  return true 
     && // fld=(decl Decl* NULL)
  // nodetype=Decl*, type=Decl*, var=decl()
(decl() == u->decl());
}


bool MonitorFetchInstanceNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MonitorFetchInstanceNode *u;
  u = (const MonitorFetchInstanceNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool MonitorLockNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MonitorLockNode *u;
  u = (const MonitorLockNode *) t;
  return true 
     && // fld=(fetcher MonitorFetchNode * NULL)
  // nodetype=MonitorFetchNode *, type=MonitorFetchNode *, var=fetcher()
(fetcher() == u->fetcher());
}


bool MonitorUnlockNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const MonitorUnlockNode *u;
  u = (const MonitorUnlockNode *) t;
  return true 
     && // fld=(fetcher MonitorFetchNode * NULL)
  // nodetype=MonitorFetchNode *, type=MonitorFetchNode *, var=fetcher()
(fetcher() == u->fetcher());
}


bool CheckNullNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const CheckNullNode *u;
  u = (const CheckNullNode *) t;
  return true 
     && // fld=(expr TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=expr()
(expr()->absent() == u->expr()->absent()) && (expr()->absent() || COMPARE(expr(), u->expr()));
}


bool AssertNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const AssertNode *u;
  u = (const AssertNode *) t;
  return true 
     && // fld=(condition TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=condition()
(condition()->absent() == u->condition()->absent()) && (condition()->absent() || COMPARE(condition(), u->condition()))
     && // fld=(value TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=value()
(value()->absent() == u->value()->absent()) && (value()->absent() || COMPARE(value(), u->value()));
}


bool TemplateNameNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TemplateNameNode *u;
  u = (const TemplateNameNode *) t;
  return true 
     && // fld=(qualifier TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=qualifier()
(qualifier()->absent() == u->qualifier()->absent()) && (qualifier()->absent() || COMPARE(qualifier(), u->qualifier()))
     && // fld=(ttype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=ttype()
(ttype()->cType() == u->ttype()->cType());
}


bool TemplateInstanceTypeNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TemplateInstanceTypeNode *u;
  u = (const TemplateInstanceTypeNode *) t;
  return true 
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(args TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=args()
COMPARE(args(), u->args())
     && // fld=(decl:class ClassDecl* NULL)
  // nodetype=ClassDecl*, type=ClassDecl*, var=decl()
(decl() == u->decl());
}


bool TemplateDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TemplateDeclNode *u;
  u = (const TemplateDeclNode *) t;
  return true 
     && // fld=(basis TypeDeclNode)
  // nodetype=TypeDeclNode*, type=TypeDeclNode *, var=basis()
(basis() == u->basis())
     && // fld=(params TreeListNode)
  // nodetype=TreeListNode*, type=llist<TreeNode*> *, var=params()
COMPARE(params(), u->params())
     && // fld=(environ Environ * NULL)
  // nodetype=Environ *, type=Environ *, var=environ()
(environ() == u->environ());
}


bool TemplateConstParamNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TemplateConstParamNode *u;
  u = (const TemplateConstParamNode *) t;
  return true 
     && // fld=(dtype TypeNode)
  // nodetype=TypeNode*, type=TypeNode *, var=dtype()
(dtype()->cType() == u->dtype()->cType())
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()));
}


bool TemplateTypeParamNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TemplateTypeParamNode *u;
  u = (const TemplateTypeParamNode *) t;
  return true 
     && // fld=(simpName TreeNode)
  // nodetype=TreeNode*, type=TreeNode *, var=simpName()
(simpName()->absent() == u->simpName()->absent()) && (simpName()->absent() || COMPARE(simpName(), u->simpName()));
}


bool TemplateInstanceDeclNode::compare (const TreeNode *t) const
{
  if (!streq(oper_name(), t->oper_name())) return false;
  const TemplateInstanceDeclNode *u;
  u = (const TemplateInstanceDeclNode *) t;
  return true 
     && // fld=(instance TypeDeclNode)
  // nodetype=TypeDeclNode*, type=TypeDeclNode *, var=instance()
(instance() == u->instance())
     && // fld=(environ Environ * NULL)
  // nodetype=Environ *, type=Environ *, var=environ()
(environ() == u->environ());
}