/***********************************
 *    dotsrc.h                     *
%$             1992-10-13          $%
 ***********************************/

#include <stdio.h>
#include <assert.h>
#include <sys/types.h>

typedef  int  Bool;

/******************   Structure Declarations  ************************/

struct program;
struct env_def;
struct def_lib;
struct string;
struct exp_def;
struct exp;
struct obj_def;
struct obj_sub;
struct mod_def;
struct m_sub;
union  m_desc;
struct m2_desc;
union  o_term;
struct link_def;
struct link;
struct m_id_pair;
struct o_term_pair;
struct rule_def;
struct rule;
struct rule_id;
union  cluster;
struct normal;
struct rel;
struct update;
struct transaction;
union  i_check_content;
struct i_check;
struct prop;
struct a_term;
struct c_o_term;
struct dot;
struct label;
union  list;
struct sub_list;
union  remain;
union  non_struct;
struct exp_name;
struct integer;
struct attr;
union  value;
struct set;
union  cnstr;
struct cnstr_data;
struct query_cnstr;
struct prolog;
struct var;
struct sort;
struct query;
union  q_mode;
struct p_mode;
struct a_mode;
struct i_mode;
struct m_mode;
struct e_mode;
struct answer;
struct answer_element;
struct anse_explanation;
struct rir_pair;
struct dot_cnstr;
struct var_cnstr;
union  explanation;
union  unit_explanation;
struct inherit;
struct merge_explanation;
struct lookup_explanation;
struct fact;
union  one_rule;
struct reduce;
struct sub_goal;
struct vc_pair;
struct constraint;
struct con;
struct assump;
struct obj_element;
struct obj_list;
struct obj_array;
union  pseudo_object;

/******************   Type Definitions  ************************/

typedef  struct program          Program;
typedef  struct env_def          EnvDef;
typedef  struct def_lib          DefLib;
typedef  struct string           String;
typedef  struct exp_def          ExpDef;
typedef  struct exp              Exp;
typedef  struct obj_def          ObjDef;
typedef  struct obj_sub          ObjSub;
typedef  struct mod_def          ModDef;
typedef  struct m_sub            MSub;
typedef  union  m_desc           MDesc;
typedef  struct m2_desc          M2Desc;
typedef  union  o_term           MId;
typedef  struct link_def         LinkDef;
typedef  struct link             Link;
typedef  struct m_id_pair        MIdPair;
typedef  struct o_term_pair      OTermPair;
typedef  struct rule_def         RuleDef;
typedef  struct rule             Rule;
typedef  struct rule_id          RuleId;
typedef  union  cluster          Cluster;
typedef  struct normal           Normal;
typedef  struct rel              Rel;
typedef  struct update           Update;
typedef  struct transaction      Transaction;
typedef  union  i_check_content  ICheckContent;
typedef  struct i_check          ICheck;
typedef  ICheck                  Consis;
typedef  ICheck                  InConsis;
typedef  struct prop             Prop;
typedef  struct a_term           ATerm;
typedef  union  o_term           OTerm;
typedef  struct c_o_term         COTerm;
typedef  struct dot              Dot;
typedef  struct label            Label;
typedef  Label                   IndLab;
typedef  Label                   SetLab;
typedef  Label                   CurlInd;
typedef  Label                   CurlSet;
typedef  union  list             List;
typedef  struct sub_list         SubList;
typedef  union  remain           Remain;
typedef  union  non_struct       NonStruct;
typedef  struct exp_name         ExpName;
typedef  struct integer          Integer;
typedef  struct attr             Attr;
typedef  union  value            Value;
typedef  struct set              Set;
typedef  union  cnstr            Cnstr;
typedef  struct cnstr_data       CnstrData;
typedef  struct query_cnstr      QueryCnstr;
typedef  struct prolog           Prolog;
typedef  struct var              Var;
typedef  struct sort             Sort;
typedef  struct query            Query;
typedef  union  q_mode           QMode;
typedef  struct p_mode           PMode;
typedef  struct a_mode           AMode;
typedef  struct i_mode           IMode;
typedef  struct m_mode           MMode;
typedef  struct e_mode           EMode;
typedef  struct answer           Answer;
typedef  struct answer_element   AnswerElement;
typedef  struct anse_explanation AnseExplanation;
typedef  struct rir_pair         RirPair;
typedef  struct dot_cnstr        DotCnstr;
typedef  struct var_cnstr        VarCnstr;
typedef  union  explanation      Explanation;
typedef  union  unit_explanation UnitExplanation;
typedef  struct inherit          Inherit;
typedef  struct merge_explanation   MergeExplanation;
typedef  struct lookup_explanation  LookupExplanation;
typedef  struct fact             Fact;
typedef  union  one_rule         OneRule;
typedef  struct reduce           Reduce;
typedef  struct sub_goal         SubGoal;
typedef  struct vc_pair          VcPair;
typedef  struct constraint       Constraint;
typedef  struct con              Con;
typedef  struct assump           Assump;
typedef  struct string           QueryExplanation; 
typedef  struct obj_element      ObjElement;
typedef  struct obj_list         ObjList;
typedef  struct obj_array        ObjArray;
typedef  union  pseudo_object    PseudoObject;

/**********************  Enumeration Constant  **********************/
typedef enum {PROGRAM=1, ENV_DEF, DEF_LIB, STRING, EXP_DEF, EXP,
		EXP_NAME, OBJ_DEF, OBJ_SUB, MOD_DEF, M_SUB, M_DESC,
		M2_DESC, LINK_DEF, LINK, M_ID_PAIR, O_TERM_PAIR,
		RULE_DEF, RULE, RULE_ID, NORMAL, REL, UPDATE,
		TRANSACTION, PROP, I_CHECK_CONTENT,I_CHECK, CONSIS, 
		INCONSIS, CLUSTER, A_TERM, O_TERM, LABEL, LAB, IND_LAB, 
		SET_LAB, CURL_IND, CURL_SET, C_O_TERM, PROLOG, VAR, DOT,
		SUB_LIST, LIST, REMAIN, INTEGER, NON_STRUCT, ATTR,
		SET, SORT, VALUE, CNSTR_DATA, QUERY_CNSTR, CNSTR,
		QUERY, P_MODE, A_MODE, I_MODE, M_MODE, E_MODE, Q_MODE,
		ANSWER, ANSWER_ELEMENT, ANSE_EXPLANATION, RIR_PAIR, 
		DOT_CNSTR, VAR_CNSTR, INHERIT,	REDUCE, SUB_GOAL, 
		VC_PAIR, ONE_RULE, FACT, UNIT_EXPLANATION, MERGE_EXPLANATION, 
		LOOKUP_EXPLANATION, EXPLANATION, CONSTRAINT, CON, ASSUMP, 
		QUERY_EXPLANATION, PSEUDO_OBJECT, OBJ_LIST, OBJ_ARRAY}
TypeDescriptor;

#define M_ID O_TERM

/*** Library Labels ***/
/*  '&exp_lib | '&pgm_lib' | '&sort_lib'  */
typedef enum{EXPLIB=1, PGMLIB, SORTLIB} LibLab;

/*** Rule Classes ***/
/*  '&no_update' | '&update' */
typedef enum {RCNOUPDATE=1, RCUPDATE} RuleClass;

/*** Rule Inheritance Mode ***/
/* '&l' | '&o' | '&lo' | '&ol' | &void  */
typedef enum {IML=1, IMO, IMLO, IMOL} InheritanceMode;

/*** No Assumption  ***/
typedef enum {NOASSUME=1} NoAssume;

/*** Update Flags ***/
/*  '+' | '-'  */
typedef enum {UFPLUS=1, UFMINUS} UFlag;

/*** Transaction Controllers ***/
/*  '&bt' | '&et' | '&at' */
typedef enum {TDBT=1, TDET, TDAT}  TrnData;

/*** Attribute Operators ***/
/*  '->' | '<-' | '=' */
typedef enum {ATRARROW=1, ATLARROW, ATEQ} AttrOp;

/*** Constraint Relations ***/
/*  '=<' | '>=' | '==' | '+<' | '>+' | '=+=' | '*<' | '>*' | '=*=' | 
    '&in' | '&ni'  */
typedef enum {CNLE=1,CNGE,CNEQ,CNPL,CNPG,CNEPE,CNAL,CNAG,CNEAE,CNIN,CNNI} 
             CnRel;

/*** VarType var$B$N%G!<%?%?%$%W(B ***/
typedef enum {VARIND=1,VARSET}  VarType;

/*** Process Mode Data ***/
/*  '&single' | '&multi'  */
typedef  enum{PSINGLE=1,PMULTI}     PModeData;

/*** Assumption Mode Data ***/
/*  '&normal' | '&minimal'  */
typedef  enum{ANORMAL=1,AMINIMAL}   AModeData;

/*** Inheritance Mode Data ***/
/*  '&all' | '&down' | '&up' | '&no'  */
typedef  enum{IALL=1,IDOWN,IUP,INO} IModeData;

/*** Merge Mode Data ***/
/*  '&yes' | '&no'  */
typedef  enum{MYES=1,MNO}           MModeData;

/*** Explanation Mode Data ***/
/*  '&on | '&off'  */
typedef  enum{EON=1,EOFF}           EModeData;


/*********************  Object List & Array   **************************/
/**** ObjElement ****/
struct obj_element {
    PseudoObject* element;
    ObjElement* next;
};

/********  ObjList  *******/
struct obj_list {
    TypeDescriptor tag;
    TypeDescriptor element_tag;   
    ObjElement*    first;
    ObjElement*    last;
};

/********  ObjArray  *******/
struct obj_array {
    TypeDescriptor tag;
    TypeDescriptor element_tag;
    size_t         size;
    PseudoObject** elements;
};

/******************  Program  ***************/
/**********************/
/*   Program          */
/**********************/
/***  $Program  ***/
struct program {
    TypeDescriptor tag;
    EnvDef*        env_def;       /* $Env_def | NULL -> &void */
    ExpDef*        exp_def;       /* $Exp_def | NULL -> &void */
    ObjDef*        obj_def;       /* $Obj_def | NULL -> &void */
    ModDef*        mod_def;       /* $Mod_def | NULL -> &void */
    LinkDef*       link_def;      /* $Link_def | NULL -> &void */
    RuleDef*       rule_def;      /* $Rule_def | NULL -> &void */
};
          /* $B%a%s%P!<$NCM$,(B NULL $B$N$H$-$O(B &void   */

/********************* Env_def *******************/
/******************/
/*  Env_def       */
/******************/
/*** $Env_def ***/
struct env_def {
    TypeDescriptor tag;  
    char*          name;      /*  atom | NULL -> &void  */
    char*          author;    /*  atom | NULL -> &void  */
    char*          date;      /*  atom | NULL -> &void */
    ObjList*       def_libs;  /* [$Def_lib ,...] */
};

/**************/
/* Def_lib    */
/**************/
/*** $Def_lib ***/
struct def_lib {
    TypeDescriptor tag;  
    LibLab         lib_lab;     /* &exp_lib|&prg_lib|&sort_lib */
    ObjList*       lib_names;   /* [String,...] */
};
          
/*** String ***/
struct string {
    TypeDescriptor tag;  
    char*          str_data;       /* $BJ8;zNs%G!<%?$X$N%]%$%s%?(B */
};

/*************************  Exp_def *************************/
/******************/
/*   Exp_def      */
/******************/
/*** $Exp_def  ***/
struct exp_def {
    TypeDescriptor tag;
    ObjList*       exps;                /* [$Exp,...] */
};

/***************/
/*  Exp        */
/***************/
/*** $Exp_name ***/
struct exp_name {
    TypeDescriptor tag;
    char*          name;                /* "e_"<string> */
};

/*** $Exp ***/
struct exp {
    TypeDescriptor tag;  
    ExpName*       exp_name;           /* $Exp_name */
    OTerm*         o_term;             /* O_term */
};

/************************ Obj_def ******************************/
/********************/
/*  Obj_def         */
/********************/
/*** $Obj_def ***/
struct obj_def {
    TypeDescriptor tag;  
    ObjList*       obj_subs;            /* [$Obj_sub,...]  */
};

/*************/
/* Obj_sub   */
/*************/
/*** obj_sub ***/
struct obj_sub {
    TypeDescriptor tag;  
    char*          bobj1;              /* atom */
    char*          bobj2;              /* atom */
};  

/********************** Mod_def ***********************************/
/*****************/
/*  Mod_def      */
/*****************/
/*** $Mod_def ***/
struct mod_def {
    TypeDescriptor tag;  
    ObjList*       m_subs;             /* [$M_sub,...] */
};

/**************/
/*  M_sub     */
/**************/
/*** $M_sub ***/
struct m_sub{
  TypeDescriptor    tag;  
  MId*              m_id;             /* $M_id */
  MDesc*            m_desc;           /* $M_desc */
};

/**************/
/* M_desc     */
/**************/
/*** $M_desc ***/
union m_desc {
  TypeDescriptor    tag;  
  MId*              m_id;           /* $M_id */
  M2Desc*           m2_desc;        /* $M_desc1, Op, $M_desc2 --> m2_desc */
};

/*** m2_desc ***/
struct m2_desc {
  TypeDescriptor    tag;  
  MDesc*            m_desc1;        /* m_desc1 */
  char              op;             /* op = +|- */
  MDesc*            m_desc2;        /* m_desc2 */
};

/***************************** Link_def ******************************/
/***************/
/* Link_def    */
/***************/
/*** $Link_def ***/
struct link_def {
    TypeDescriptor tag;  
    ObjList*       links;           /* [$Link,...] */
};

/**************/
/*  Link      */
/**************/
/*** $Link ***/
struct link {
  TypeDescriptor    tag;  
  char*             link_name; /* atom */
  ObjList*          m_ids;     /* [{$M_id1,$Mid2},...] */
  ObjList*          o_terms;   /* [{$O_term1,$O_term2},...] */
};

/* m_id_pair ---> {$M_id1,$Mid2} */
struct m_id_pair {
  TypeDescriptor    tag;  
  MId*              m_id1;
  MId*              m_id2;
};

/* o_term_pair ---> {$O_term1,$O_term2} */
struct o_term_pair {
  TypeDescriptor    tag;  
  OTerm*            o_term1;
  OTerm*            o_term2;
};

/*************************** Rule_def **********************/
/*******************/
/*   Rule_def      */
/*******************/
/*** $Rule_def ***/
struct rule_def {
    TypeDescriptor    tag;  
    ObjList*          rules;      /* [$Rule,...] */
};

/*****************/
/*   Rule        */
/*****************/
/*** $Rule ***/
struct rule {
    TypeDescriptor    tag;  
    RuleClass         rule_class;        /* &no_update | &update */
    ObjList*          m_ids;             /* [$M_id,...] */
    RuleId*           rule_id;           /* String | &void */
    InheritanceMode   inheritance_mode;  /* &l | &o | &lo | &ol */
    NoAssume          no_assume;         /* '&no_assume' | &void */
    ATerm*            a_term;            /* $A_term */
    ObjList*          clusters;          /* [$Cluster,...] */
    ObjList*          cnstrs;            /* [$Cnstr,..] */
};

/*** RuleId ***/
struct rule_id {
   TypeDescriptor   tag;
   char*            rule_id_string;
};

/************/
/*  Cluster */
/************/
/*** normal ***/
struct normal {
  TypeDescriptor    tag;  
  MId*              m_id;           /* $Mid */
  ATerm*            a_term;         /* $A_term */
};

/*** rel ***/
struct rel {
    TypeDescriptor tag;  
    OTerm*         o_term1;    /* $O_term  */
    CnRel          sub_rel;    /* '<=' |  '>=' | '==' */
    OTerm*         o_term2;    /* $O_term  */
};

/*** update ***/
struct update {
    TypeDescriptor    tag;  
    UFlag             u_flag;      /*  '+' | '-' */
    MId*              m_id;       /* $Mid */
    ATerm*            a_term;     /* $A_term */
};

/*** transaction ***/
struct transaction {
  TypeDescriptor    tag;  
  TrnData           trn_data;    /* '&bt' | '&et' | '&at'  */
};

/***********/
/* I_check */
/***********/
/** Prop **/
struct prop {
  TypeDescriptor    tag;  
  MId*              m_id;      /* $Mid */
  ATerm*            a_term;     /* $A_term */
};

/*** $I_check_conyent  ***/
union i_check_content {
  TypeDescriptor    tag;  
  Prop              prop;      /* prop$B$N%G!<%?(B  */
  ObjList           cnstrs;    /* [$Cnstr,...] */
};

/*** $I_check **/
struct i_check {
     TypeDescriptor   tag;
  ICheckContent    *i_check_content;
};

/*** $Cluster ***/
union cluster {
  TypeDescriptor    tag;  
  Normal            normal;        
  Rel               rel;
  Update            update;
  Transaction       transaction;
  Consis            consis;
  InConsis          inconsis;
};

/********************  A_term  *******************************/
/**************/
/*  A_term    */
/**************/
/*** $A_term  ***/
struct a_term {
    TypeDescriptor    tag;
    OTerm*            o_term;    /* $Oterm  */
    ObjList*          attrs;      /* [$Attr,...]  */
    ObjList*          cnstrs;     /* [$Cnstr,...]  */
};

/*********************  O_term  *********************************/
/*** $Label ***/
/** Label **/
struct label {
    TypeDescriptor    tag;
    OTerm*            o_term;
};

/*****************/
/*  C_o_term     */
/*****************/
/*** $C_o_term ***/
struct c_o_term {
    TypeDescriptor    tag;  
    char*             head;      /* atom */
    ObjList*          attrs;     /* [$Attr,...] */
    ObjList*          cnstrs;    /* [$Cnstr,...] */
};

/**************/
/*  Prolog    */
/**************/
struct  prolog{
   TypeDescriptor    tag;  
   char*             head;
   ObjList*          o_terms;
 };

/***********/
/*  Var    */
/***********/
/*** $Var ***/
struct var {
  TypeDescriptor    tag;  
  VarType           type;       /* var$B%G!<%?$N%?%$%W<1JL(B   ind or set */
  char*             var_data;   /* var$B$N%G!<%?(B  String */
};
         
/*************/
/* Dot       */
/*************/
/*** $Dot ***/
struct dot {
  TypeDescriptor     tag;  
  OTerm*             o_term;   /* $O_term */
  Label*             label;    /* $Label = $O_term */
};

/************/
/* List     */
/************/
/*** sub_list  {[$O_term,...],Remain} ***/
struct sub_list {
    TypeDescriptor tag;
    ObjList*       o_terms;     /* [$O_term,..] */
    Remain*        remain;      /* Remain */
};

/*** $List ***/
union list {
    TypeDescriptor tag;
    ObjList        normal;    /*  [$O_term,...]          */
    SubList        sub_list;  /*  {[$O_term,...],Remain} */
};
/* nil([]) $B$O(BNULL $B$GI=$9(B */

/*** Remain ***/
/* Remain = $List | $Var  */
union remain {
    TypeDescriptor tag;
    List           list;
    Var            var;
};

/***************/
/* Non_struct  */
/***************/
/*** Integer ***/
struct integer {
    TypeDescriptor tag;  
    int            value;
};

/*** $Non_struct ***/
union non_struct {
    TypeDescriptor tag;  
    ExpName        exp_name;
    String         string;
    Integer        integer;
};

/**************/
/*  O_term    */
/**************/
/*** $O_term ***/
union o_term {
  TypeDescriptor    tag;  
  Prolog            prolog;      /*  $Progaram */
  COTerm            c_o_term;     /*  $C_o_term */
  Var               var;          /*  $Var */
  Dot               dot;          /*  $Dot */
  List              list;         /*  $List */
  NonStruct         non_struct;   /*  $Non_struct */
};

/**************************  ETC ************************************/
/**************/
/* Attr       */
/**************/
/*** $Attr ***/

struct attr {
    TypeDescriptor    tag;  
    Label*            label;        /* $Label */
    AttrOp            attr_op;      /*   '->' | '<-' | '=='  */
    Value*            value;        /* $Value */
};

/*** $Set ***/
struct set {
    TypeDescriptor    tag;  
    ObjList*          o_terms;       /*  [$O_term,...] */
};

/*****************/
/* Sort          */
/*****************/         
/*** $Sort ***/
struct sort {
    TypeDescriptor tag;
    Prolog*        prolog;   /*  $Prolog ???  */
};

/*** $Value ***/
/* $Value = $Set | $Sort | $OTerm */

/*** value_data ***/
union value {
    TypeDescriptor    tag;  
    Set               set;          /* $Set */
    Sort              sort;         /* $Sort */
    OTerm             o_term;       /* $O_term */
};

/**************/
/* Cnstr      */
/**************/
/*** query_cnstr ***/
struct query_cnstr {
    TypeDescriptor tag;
    MId* m_id1;
    MId* m_id2;
};

/*** cnstr_data ***/
struct cnstr_data {
    TypeDescriptor    tag;  
    MId*              m_id1;       /* $M_id | NULL -> &void */
    Value*            value1;      /* $Value */
    CnRel             rel;         /* '=<' | '>=' | '==' | '+<' | '>+' */
                                   /* '=+=' |'&in" | '&ni' */
    MId*              m_id2;       /* $M_id | NULL -> &void */
    Value*            value2;      /* $Value */
};

/*** $Cnstr ***/
union cnstr {
    TypeDescriptor tag;
    CnstrData      cnstr;
    QueryCnstr     query_cnstr;
};  

/********************  Query ********************************/
/*************/
/* Query     */
/*************/
/*** query ***/
struct query {
    TypeDescriptor    tag;  
    RuleClass         query_class;    /* &no_update | &update  */
    ATerm*            q_head;         /* $A_term | &void */
    ObjList*          clusters;       /* [$Cluster,...] */
    ObjList*          cnstrs;         /* [Cnstr,...]    */
    ObjList*          q_modes;        /* [Q_mode,...]   */
    Program*          program;        /* Program | &void = NULL  */
};

/*** P_mode ***/
struct p_mode {
    TypeDescriptor tag;  
    PModeData      p_mode_data;
};

/*** A_mode ***/
struct a_mode {
    TypeDescriptor tag;  
    AModeData      a_mode_data;
};

/*** I_mode ***/
struct i_mode {
    TypeDescriptor tag;  
    IModeData      i_mode_data;
};

/*** M_mode ***/
struct  m_mode {
    TypeDescriptor tag;  
    MModeData      m_mode_data;
};

/*** E_mode ***/
struct e_mode {
    TypeDescriptor tag;  
    EModeData      e_mode_data;
};

/*** q_mode ***/
union q_mode {
    TypeDescriptor tag;  
    PMode          p_mode;
    AMode          a_mode;
    IMode          i_mode;
    MMode          m_mode;
    EMode          e_mode;
};

/*************/
/*  Answer   */
/*************/
/*** $Answer ***/
struct answer {
    TypeDescriptor    tag;  
    ObjList*          answer_elements;   /* [$Answer_element,..] */
};

/**** $Answer_element ***/
struct answer_element {
    TypeDescriptor    tag;  
    ObjList*          dot_cnstrs;        /* [$Dot_cnstr,..] */
    ObjList*          var_cnstrs;        /* [$Var_cnstr,..] */
    AnseExplanation*  anse_explanation;       
};
 
/*** answer_element_explanation ***/
struct anse_explanation {
    TypeDescriptor    tag;  
    Explanation*      explanation;        
    ObjList*          rir_pairs;         /* [{Rule_id, $Rule},...] */
};
  
/*** pair_of_rule_id_and_rule ***/
struct rir_pair {
    TypeDescriptor    tag;  
    RuleId*           rule_id;
    Rule*             rule;
};

/*************/
/* Dot_cnstr */
/*************/
/*** $Dot_cnstr ***/
struct dot_cnstr {
  TypeDescriptor    tag;  
  MId*              m_id;      /* $M_id | NULL -> &void */
  Dot*              dot;       /*  $Dot  */
  CnRel             rel;       /* '=<' | '>=' | '==' | '*<' | '>*' | '=*='*/
  Value*            value;     /* $Value */
};

/*************/
/* Var_cnstr */
/*************/
/*** $Var_cnstr ***/
struct var_cnstr {
  TypeDescriptor    tag;  
  Var*              var;       /* $Var */
  CnRel             rel;       /* '=<' | '>=' | '==' | '*<' | '>*' | '=*='*/
  Value*            value;     /* $Value */
};

/****************/
/* Explanation  */
/****************/
/*** inherit ***/
/*  inherit({$One_rule,Up,Down}) */
struct inherit {
    TypeDescriptor tag;
    OneRule*       one_rule;   /* $One_rule  */
    ObjList*       ups;        /* up([$OneRule,..] | &void = NULL */
    ObjList*       downs;      /* down([$OneRule,..] | &void = NULL */
};

/***************/
/*  One_rule   */
/***************/
/*** Reduce ***/
struct reduce {
    TypeDescriptor tag;
    SubGoal*       sub_goal;    /* $Subgoal */
    RuleId*        rule_id;     /* Rule_id */
    ObjList*       explanations; /* [$Explanation,..] */
    ObjList*       assumps;   /* [&Assump,...] | &void = NULL */
};  

/*************/
/* Subgoal   */
/*************/
struct sub_goal {
    TypeDescriptor tag;  
    MId*           m_id;              /* $MId */
    OTerm*         o_term;            /* $O_term */
    ObjList*       vc_pairs;          /* [{$Var,$Constraint},...] */
};

/*** vc_pair ***/
struct vc_pair {
  TypeDescriptor tag;  
  Var*           var;               /* $Var */
  Constraint*    constraint;        /* $Constraint */
};

/*** Fact ***/
struct fact {
    TypeDescriptor   tag;  
    char*            fact_data;
};

/*** $One_rule ***/
union one_rule {
    TypeDescriptor   tag;  
    Reduce           reduce;  /* {$Subgoal,Rule_id,[$Explanation,..],Assump} */
    Fact             rule_id; /* string */
    QueryExplanation query;   /* query $B$H$$$&(B atom */
};


/*********************/
/* Unit_explanation  */
/*********************/
/*** $Unit_explanation ***/
/* unit($Unit_explanation) */
union unit_explanation {
    TypeDescriptor tag;  
    OneRule        one_rule;
    Inherit        inherit;
};

/*** $MergeExplanation ***/
/* merge([$Unit_explanation,...]) */
struct merge_explanation {
    TypeDescriptor tag;  
    ObjList*       unit_explanations;   /* [$Unit_explanation,...] */
};

/*** $LookupExplanation  ***/
/* lookup({$Subgoal, LookedS, LookingS, $Explanation}) */
struct lookup_explanation {
    TypeDescriptor    tag;  
    SubGoal*          sub_goal;            /* $Subgoal */
    int               looked_s;            /* LookedS */
    int               looking_s;           /* LookingS */
    Explanation*      explanation;         /* $Explanation */
};

/*** $Explanation ***/
union explanation {
    TypeDescriptor    tag;  
    UnitExplanation   unit;   /* $Unit_explanation */
    MergeExplanation  merge;  /* [$Unit_explanation,...] */
    LookupExplanation lookup; /* {$Subgoal,LookedS,LookingS,$Expalnation} */
};

/***************/
/* Constraint  */
/***************/
struct constraint{
    TypeDescriptor tag;  
    Con*           const_data;  /*  con({[$O_term,..],[$O_term,..]} | &void */
};

/*** con ***/
/*  {[$O_term,..],[$O_term,..]}  */
struct con {
    TypeDescriptor tag;  
    ObjList*       o_terms1;     /* [$O_term,..] */
    ObjList*       o_terms2;     /* [$O_term,..] */
};

/**************/
/* Assump     */
/**************/
/*** $Assump  ***/
struct assump {
    TypeDescriptor tag;  
    MId*           m_id;           /* $M_id | NULL -> &void  */
    Dot*           dot;            /* $Dot */
    ObjList*       vc_pairs;       /* [{$Var,$Constraint},...] */
};

/**** PseudoObject ****/
union pseudo_object {
    TypeDescriptor  tag;
    Program         program;
    EnvDef          env_def;
    DefLib          def_lib;
    String          string;
    Exp             exp;
    ObjSub          obj_sub;
    MSub            m_sub;
    Link            link;
    MIdPair         m_id_pair;
    OTermPair       o_term_pair;
    Rule            rule;
    Cluster         cluster;
    OTerm           oterm;
    Attr            attr;
    Set             set;
    Cnstr           cnstr;
    QMode           q_mode;
    AnswerElement   answer_element;
    DotCnstr        dot_cnstr;
    VarCnstr        var_cnstr;
    VcPair          vc_pair;
    OneRule         one_rule;
    UnitExplanation unit_explanation;
    Explanation     explanation;
};
/** identification macros **/

#define is_program_non_NULL(A) ((A)->tag == PROGRAM)
#define fis_program_non_NULL(A) is_program_non_NULL((A))
#define is_env_def_non_NULL(A) ((A)->tag == ENV_DEF)
#define fis_env_def_non_NULL(A) is_env_def_non_NULL((A))
#define is_def_lib_non_NULL(A) ((A)->tag == DEF_LIB)
#define fis_def_lib_non_NULL(A) is_def_lib_non_NULL((A))
#define is_string_non_NULL(A) ((A)->tag == STRING)
#define fis_string_non_NULL(A) is_string_non_NULL((A))
#define is_exp_def_non_NULL(A) ((A)->tag == EXP_DEF)
#define fis_exp_def_non_NULL(A) is_exp_def_non_NULL((A))
#define is_exp_non_NULL(A) ((A)->tag == EXP)
#define fis_exp_non_NULL(A) is_exp_non_NULL((A))
#define is_obj_def_non_NULL(A) ((A)->tag == OBJ_DEF)
#define fis_obj_def_non_NULL(A) is_obj_def_non_NULL((A))
#define is_obj_sub_non_NULL(A) ((A)->tag == OBJ_SUB)
#define fis_obj_sub_non_NULL(A) is_obj_sub_non_NULL((A))
#define is_obj_list_non_NULL(A, B) \
  ((A)->tag == OBJ_LIST && is_type(((ObjList*)(A))->element_tag, B))
#define is_any_obj_list_non_NULL(A) ((A)->tag == OBJ_LIST)
#define is_obj_array_non_NULL(A, B) \
  ((A)->tag == OBJ_ARRAY && is_type(((ObjList*)(A))->element_tag, B))
#define is_any_obj_array_non_NULL(A) ((A)->tag == OBJ_ARRAY)
#define fis_any_obj_array_non_NULL(A) is_any_obj_array_non_NULL((A))

#define is_program(A) ((A) == NULL || is_program_non_NULL(A))
#define is_env_def(A) ((A) == NULL || is_env_def_non_NULL(A))
#define is_def_lib(A) ((A) == NULL || is_def_lib_non_NULL(A))
#define is_string(A) ((A) == NULL || is_string_non_NULL(A))
#define is_exp_def(A) ((A) == NULL || is_exp_def_non_NULL(A))
#define is_exp(A) ((A) == NULL || is_exp_non_NULL(A))
#define is_obj_def(A) ((A) == NULL || is_obj_def_non_NULL(A))
#define is_obj_sub(A) ((A) == NULL || is_obj_sub_non_NULL(A))
#define is_obj_list(A, B) ((A) == NULL || is_obj_list_non_NULL(A, B))
#define is_any_obj_list(A) ((A) == NULL || is_any_obj_list_non_NULL(A))
#define is_obj_array(A, B) ((A) == NULL || is_obj_array_non_NULL(A, B))
#define is_any_obj_array(A) ((A) == NULL || is_any_obj_array_non_NULL(A))
/**  identification macros **/
#define  is_mod_def(A) ((A)== NULL || (A)->tag == MOD_DEF)
#define  is_mod_def_non_NULL(A) ((A) != NULL && (A)->tag == MOD_DEF)

#define  is_m_sub(A) ((A)== NULL || (A)->tag == M_SUB)
#define  is_m_sub_non_NULL(A) ((A) != NULL && (A)->tag == M_SUB)

#define  is_rule(A) ((A)== NULL || (A)->tag == RULE)

#define  is_o_term(A) ((A)== NULL || (A)->tag == O_TERM || is_prolog(A)\
                      || is_c_o_term(A) || is_var(A) || is_dot(A)\
                      || is_list(A) || is_non_struct(A))
#define  is_o_term_non_NULL(A) ((A) != NULL && (A)->tag == O_TERM || is_prolog(A)\
                      || is_c_o_term(A) || is_var(A) || is_dot(A)\
                      || is_list(A) || is_non_struct(A))

#define  is_m_id(A) ((A)== NULL || is_o_term(A) || (A)->tag == M_ID || (A)->tag == O_TERM)

#define  is_m_desc(A) ((A)== NULL || (A)->tag == M_DESC || is_m_id(A) || is_m2_desc(A))
#define  is_m_desc_no_NULL(A) ((A)!= NULL && (A)->tag == M_DESC || is_m_id(A) || is_m2_desc(A))

#define  is_m2_desc(A) ((A)== NULL || (A)->tag == M2_DESC)
#define  is_m2_desc_non_NULL(A) ((A)!= NULL && (A)->tag == M2_DESC)

#define  is_link_def(A) ((A)== NULL || (A)->tag == LINK_DEF)
#define  is_link_def_non_NULL(A) ((A)!= NULL && (A)->tag == LINK_DEF)

#define  is_link(A) ((A)== NULL || (A)->tag == LINK)
#define  is_link_non_NULL(A) ((A)!= NULL && (A)->tag == LINK)

#define  is_m_id_pair(A) ((A)== NULL || (A)->tag == M_ID_PAIR)
#define  is_m_id_pair_non_NULL(A) ((A)!= NULL && (A)->tag == M_ID_PAIR)

#define  is_o_term_pair(A) ((A)== NULL || (A)->tag == O_TERM_PAIR)
#define  is_o_term_pair_non_NULL(A) ((A)!= NULL && (A)->tag == O_TERM_PAIR)

#define  is_rule_def(A) ((A)== NULL || (A)->tag == RULE_DEF)
#define  is_rule_def_non_NULL(A) ((A)!= NULL && (A)->tag == RULE_DEF)

#define  is_rule(A) ((A)== NULL || (A)->tag == RULE)
#define  is_rule_non_NULL(A) ((A)!= NULL && (A)->tag == RULE)

#define  is_rule_id(A) ((A)== NULL || (A)->tag == RULE_ID)
#define  is_rule_id_non_NULL(A) ((A)!= NULL && (A)->tag == RULE_ID)

#define  is_cluster(A) ((A)== NULL || (A)->tag == CLUSTER\
         || is_normal(A) || is_rel(A) || is_update(A)\
         ||is_transaction(A) || is_i_check(A))
#define  is_cluster_non_NULL(A) ((A)!= NULL && is_(A)->tag == CLUSTER\
         || is_normal(A) || is_rel(A) || is_update(A)\
         || is_transactiob(A) || is_i_check(A))

#define  is_normal(A) ((A)== NULL || (A)->tag == NORMAL)
#define  is_normal_non_NULL(A) ((A)!= NULL && (A)->tag == NORMAL)

#define  is_rel(A) ((A)== NULL || (A)->tag == REL)
#define  is_rel_non_NULL(A) ((A)!= NULL && (A)->tag == REL)

#define  is_update(A) ((A)== NULL || (A)->tag == UPDATE)
#define  is_update_non_NULL(A) ((A)!= NULL && (A)->tag == UPDATE)

#define  is_transaction(A) ((A)== NULL || (A)->tag == TRANSACTION)
#define  is_transaction_non_NULL(A) ((A)!= NULL && (A)->tag == TRANSACTION)

#define  is_i_check_content(A) ((A)== NULL || (A)->tag == I_CHECK_CONTENT\
                                 || is_prop(A) || is_obj_list(A,CNSTR))
#define  is_i_check_content_non_NULL(A) ((A)!= NULL && ((A)->tag == I_CHECK_CONTENT\
                                 || is_prop(A) || is_obj_list(A,CNSTR)))

#define  is_i_check(A)  ((A) == NULL || (A)->tag == I_CHECK\
                            || (A)->tag == CONSIS || (A)->tag == INCONSIS)
#define  is_i_check_non_NULL(A)  ((A) != NULL && ((A)->tag == I_CHECK\
                            || (A)->tag == CONSIS || (A)->tag == INCONSIS))

#define  is_consis(A)  ((A) == NULL || (A)->tag == CONSIS)
#define  is_consis_non_NULL(A)  ((A) == NULL && (A)->tag == CONSIS)

#define  is_inconsis(A)  ((A) == NULL || (A)->tag == INCONSIS)
#define  is_inconsis_non_NULL(A)  ((A) == NULL && (A)->tag == INCONSIS)

#define  is_prop(A) ((A)== NULL || (A)->tag == PROP)
#define  is_prop_non_NULL(A) ((A)!= NULL && (A)->tag == PROP)

#define  is_a_term(A) ((A)== NULL || (A)->tag == A_TERM)
#define  is_a_term_non_NULL(A) ((A)!= NULL && (A)->tag == A_TERM)

#define  is_c_o_term(A) ((A)== NULL || (A)->tag == C_O_TERM)
#define  is_c_o_term_non_NULL(A) ((A)!= NULL && (A)->tag == C_O_TERM)

#define  is_dot(A) ((A)== NULL || (A)->tag == DOT)
#define  is_dot_non_NULL(A) ((A)!= NULL && (A)->tag == DOT)

#define  is_label(A) ((A)== NULL || (A)->tag == LABEL ||(A)->tag == IND_LAB\
                    || (A)->tag == SET_LAB || (A)->tag == CURL_IND || (A)->tag == CURL_SET)
#define  is_label_non_NULL(A) ((A)!= NULL && ((A)->tag == LABEL || (A)->tag == IND_LAB\
       || (A)->tag == SET_LAB  || (A)->tag == CURL_IND || (A)->tag == CURL_SET))

#define  is_ind_lab(A) ((A) == NULL || (A)->tag == IND_LAB)
#define  is_ind_lab_non_NULL(A) ((A)!=NULL && ((A)->tag == IND_LAB))

#define  is_set_lab(A) ((A) == NULL || (A)->tag == SET_LAB)
#define  is_set_lab_non_NULL(A) ((A)!=NULL && ((A)->tag == SET_LAB))

#define  is_curl_ind(A) ((A) == NULL || (A)->tag == CURL_IND)
#define  is_curl_ind_non_NULL(A) ((A)!=NULL && ((A)->tag == CURL_IND))

#define  is_curl_set(A) ((A) == NULL || (A)->tag == CURL_SET)
#define  is_curl_set_non_NULL(A) ((A)!=NULL && ((A)->tag == CURL_SET))

#define  is_list(A) ((A)== NULL || (A)->tag == LIST || is_obj_list(A,NORMAL) || is_sub_list(A))
#define  is_list_non_NULL(A) ((A)!= NULL && (A)->tag == LIST || is_obj_list(A,NORMAL) ||is_sub_list(A))

#define  is_sub_list(A) ((A)== NULL || (A)->tag == SUB_LIST)
#define  is_sub_list_non_NULL(A) ((A)!= NULL && (A)->tag == SUB_LIST)

#define  is_remain(A) ((A)== NULL || (A)->tag == REMAIN || is_list(A) || is_var(A))
#define  is_remain_non_NULL(A) ((A)!= NULL && (A)->tag == REMAIN || is_list(A) || is_var(A))

#define  is_non_struct(A) ((A)== NULL || (A)->tag == NON_STRUCT || is_exp_name(A) || is_string(A)\
                          || is_integer(A))
#define  is_non_struct_non_NULL(A) ((A)!= NULL && (A)->tag == NON_STRUCT || is_exp_name(A)\
                          || is_string(A) || is_integer(A))

#define  is_exp_name(A) ((A)== NULL || (A)->tag == EXP_NAME)
#define  is_exp_name_non_NULL(A) ((A)!= NULL && (A)->tag == EXP_NAME)

#define  is_integer(A) ((A)== NULL || (A)->tag == INTEGER)
#define  is_integer_non_NULL(A) ((A)!= NULL && (A)->tag == INTEGER)

#define  is_attr(A) ((A)== NULL || (A)->tag == ATTR)
#define  is_attr_non_NULL(A) ((A)!= NULL && (A)->tag == ATTR)
/** identification macros **/

#define is_set_non_NULL(A) ((A)->tag == SET)
#define is_value_non_NULL(A) ((A)->tag == VALUE || \
  is_set_non_NULL(A) || is_sort_non_NULL(A) || is_o_term_non_NULL(A))
#define is_cnstr_data_non_NULL(A) ((A)->tag == CNSTR_DATA)
#define is_query_cnstr_non_NULL(A) ((A)->tag == QUERY_CNSTR)
#define is_cnstr_non_NULL(A) ((A)->tag == CNSTR || \
  is_cnstr_data_non_NULL(A) || is_query_cnstr_non_NULL(A))
#define is_prolog_non_NULL(A) ((A)->tag == PROLOG)
#define is_var_non_NULL(A) ((A)->tag == VAR)
#define is_sort_non_NULL(A) ((A)->tag == SORT)
#define is_query_non_NULL(A) ((A)->tag == QUERY)
#define is_p_mode_non_NULL(A) ((A)->tag == P_MODE)
#define is_a_mode_non_NULL(A) ((A)->tag == A_MODE)
#define is_i_mode_non_NULL(A) ((A)->tag == I_MODE)
#define is_m_mode_non_NULL(A) ((A)->tag == M_MODE)
#define is_e_mode_non_NULL(A) ((A)->tag == E_MODE)
#define is_q_mode_non_NULL(A) ((A)->tag == Q_MODE || \
  is_p_mode_non_NULL(A) || is_a_mode_non_NULL(A) || \
  is_i_mode_non_NULL(A) || is_m_mode_non_NULL(A) || is_e_mode_non_NULL(A))
#define is_answer_non_NULL(A) ((A)->tag == ANSWER)
#define is_answer_element_non_NULL(A) ((A)->tag == ANSWER_ELEMENT)
#define is_anse_explanation_non_NULL(A) ((A)->tag == ANSE_EXPLANATION)
#define is_rir_pair_non_NULL(A) ((A)->tag == RIR_PAIR)
#define is_dot_cnstr_non_NULL(A) ((A)->tag == DOT_CNSTR)
#define is_var_cnstr_non_NULL(A) ((A)->tag == VAR_CNSTR)



#define is_set(A) ((A) == NULL || is_set_non_NULL(A))
#define is_value(A) ((A) == NULL || is_value_non_NULL(A))
#define is_cnstr_data(A) ((A) == NULL || is_cnstr_data_non_NULL(A))
#define is_query_cnstr(A) ((A) == NULL || is_query_cnstr_non_NULL(A))
#define is_cnstr(A) ((A) == NULL || is_cnstr_non_NULL(A))
#define is_prolog(A) ((A) == NULL || is_prolog_non_NULL(A))
#define is_var(A) ((A) == NULL || is_var_non_NULL(A))
#define is_sort(A) ((A) == NULL || is_sort_non_NULL(A))
#define is_query(A) ((A) == NULL || is_query_non_NULL(A))
#define is_p_mode(A) ((A) == NULL || is_p_mode_non_NULL(A))
#define is_a_mode(A) ((A) == NULL || is_a_mode_non_NULL(A))
#define is_i_mode(A) ((A) == NULL || is_i_mode_non_NULL(A))
#define is_m_mode(A) ((A) == NULL || is_m_mode_non_NULL(A))
#define is_e_mode(A) ((A) == NULL || is_e_mode_non_NULL(A))
#define is_q_mode(A) ((A) == NULL || is_q_mode_non_NULL(A))
#define is_answer(A) ((A) == NULL || is_answer_non_NULL(A))
#define is_answer_element(A) ((A) == NULL || is_answer_element_non_NULL(A))
#define is_anse_explanation(A) ((A) == NULL || is_anse_explanation_non_NULL(A))
#define is_rir_pair(A) ((A) == NULL || is_rir_pair_non_NULL(A))
#define is_dot_cnstr(A) ((A) == NULL || is_dot_cnstr_non_NULL(A))
#define is_var_cnstr(A) ((A) == NULL || is_var_cnstr_non_NULL(A))






/** identification macros **/

#define is_inherit_non_NULL(A) ((A)->tag == INHERIT)
#define is_reduce_non_NULL(A) ((A)->tag == REDUCE)
#define is_sub_goal_non_NULL(A) ((A)->tag == SUB_GOAL)
#define is_vc_pair_non_NULL(A) ((A)->tag == VC_PAIR)
#define is_query_explanation_non_NULL(A) ((A)->tag == QUERY_EXPLANATION)
#define is_fact_non_NULL(A) ((A)->tag == FACT)
#define is_one_rule_non_NULL(A) ((A)->tag == ONE_RULE || \
  is_reduce_non_NULL(A) || is_fact_non_NULL(A) || \
  is_query_explanation_non_NULL(A))
#define is_unit_explanation_non_NULL(A) ((A)->tag == UNIT_EXPLANATION || \
  is_one_rule_non_NULL(A) || is_inherit_non_NULL(A))
#define is_merge_explanation_non_NULL(A) ((A)->tag == MERGE_EXPLANATION)
#define is_lookup_explanation_non_NULL(A) ((A)->tag == LOOKUP_EXPLANATION)
#define is_explanation_non_NULL(A) ((A)->tag == EXPLANATION || \
  is_unit_explanation_non_NULL(A) || is_merge_explanation_non_NULL(A) || \
  is_lookup_explanation_non_NULL(A))
#define is_constraint_non_NULL(A) ((A)->tag == CONSTRAINT)
#define is_con_non_NULL(A) ((A)->tag == CON)
#define is_assump_non_NULL(A) ((A)->tag == ASSUMP)



#define is_inherit(A) ((A) == NULL || is_inherit_non_NULL(A))
#define is_reduce(A) ((A) == NULL || is_reduce_non_NULL(A))
#define is_sub_goal(A) ((A) == NULL || is_sub_goal_non_NULL(A))
#define is_vc_pair(A) ((A) == NULL || is_vc_pair_non_NULL(A))
#define is_query_explanation(A) ((A) == NULL || \
  is_query_explanation_non_NULL(A))
#define is_fact(A) ((A) == NULL || is_fact_non_NULL(A))
#define is_one_rule(A) ((A) == NULL || is_one_rule_non_NULL(A))
#define is_unit_explanation(A) ((A) == NULL || \
  is_unit_explanation_non_NULL(A))
#define is_merge_explanation(A) ((A) == NULL || \
  is_merge_explanation_non_NULL(A))
#define is_lookup_explanation(A) ((A) == NULL || \
  is_lookup_explanation_non_NULL(A))
#define is_explanation(A) ((A) == NULL || is_explanation_non_NULL(A))
#define is_constraint(A) ((A) == NULL || is_constraint_non_NULL(A))
#define is_con(A) ((A) == NULL || is_con_non_NULL(A))
#define is_assump(A) ((A) == NULL || is_assump_non_NULL(A))
#define Public
#define Local static

#define TRUE (0==0)
#define FALSE (!TRUE)

/** read write macro prototypes **/

#define mread(OBJECT, STRUCT_IN_STRING, IS_NON_NULL, MEMBER, MACRO) \
  ((OBJECT) == NULL \
   ? NULL \
   : IS_NON_NULL((OBJECT)) \
       ? (OBJECT)->MEMBER \
       : (type_error((OBJECT), (STRUCT_IN_STRING), (MACRO)), \
	  (OBJECT)->MEMBER))

#define mwrite(OBJECT, ARG, STRUCT_IN_STRING, IS_NON_NULL, MEMBER, MACRO) \
  ((OBJECT) == NULL \
   ? (write_through_NULL((MACRO)), (OBJECT)) \
   : IS_NON_NULL((OBJECT)) \
     ? ((OBJECT)->MEMBER = (ARG), (OBJECT)) \
     : (type_error((OBJECT), (STRUCT_IN_STRING), (MACRO)), (OBJECT)))

/** memory management macros and tyep definitions **/

#include "mdebug.h"

#ifdef MALLOC_DEBUG
#define dotsrc_malloc(A)   dotsrc_dmalloc(A)
#define dotsrc_calloc(A,B) dotsrc_dcalloc(A,B)
#define dotsrc_free(A)     dotsrc_dfree(A)
#else
#define dotsrc_malloc(A)   dotsrc_cmalloc(A)
#define dotsrc_calloc(A,B) dotsrc_ccalloc(A,B)
#define dotsrc_free(A)     dotsrc_cfree(A)
#endif

typedef enum {Malloc, Calloc} AllocType;

typedef struct malloc_log {
    AllocType tag;
    char* ptr;
    int size;
} MallocLog;

typedef struct calloc_log {
    AllocType tag;
    char* ptr;
    int nelem;
    int elsize;
} CallocLog;

typedef union alloc_log {
    AllocType tag;
    MallocLog malloc_log;
    CallocLog calloc_log;
} AllocLog;

/** declarations for common functions **/

char*         type_name();

Bool          is_type();

void          print_program();
void          print_env_def();
void          print_def_lib();
void          print_string();
void          print_exp_def();
void          print_exp();
void          print_obj_def();
void          print_obj_sub();
void          print_mod_def();
void          print_m_sub();
void          print_m_desc();
void          print_m2_desc();
void          print_o_term();
void          print_link_def();
void          print_link();
void          print_m_id_pair();
void          print_o_term_pair();
void          print_rule_def();
void          print_rule();
void          print_rule_id();
void          print_cluster();
void          print_normal();
void          print_rel();
void          print_update();
void          print_transaction();
void          print_i_check();
void          print_prop();
void          print_a_term();
void          print_o_term();
void          print_c_o_term();
void          print_dot();
void          print_label();
void          print_lab();
void          print_list();
void          print_sub_list();
void          print_remain();
void          print_non_struct();
void          print_exp_name();
void          print_integer();
void          print_attr();
void          print_value();
void          print_set();
void          print_cnstr();
void          print_cnstr_data();
void          print_query_cnstr();
void          print_var();
void          print_sort();
void          print_query();
void          print_q_mode();
void          print_p_mode();
void          print_a_mode();
void          print_i_mode();
void          print_m_mode();
void          print_e_mode();
void          print_answer();
void          print_answer_element();
void	      print_anse_explanation();
void	      print_rir_pair();
void          print_dot_cnstr();
void          print_var_cnstr();
void          print_explanation();
void          print_explanation_data();
void          print_lookup();
void          print_unit_explanation();
void          print_unit_exp_data();
void          print_inherit();
void          print_up_down();
void          print_merge_explanation();
void          print_lookup_explanation();
void          print_one_rule();
void          print_fact();
void          print_reduce();
void          print_sub_goal();
void          print_vc_pair();
void          print_constraint();
void          print_con();
void          print_assump();
void          print_query_explanation();
void          print_obj_list();
void          print_obj_array();
void          print_pseudo_object();

void          delete_pseudo_object();

PseudoObject* copy_pseudo_object();

void          type_error();
void          type_conflict();
void          write_through_NULL();
void          illegal_type_descriptor();

char*         dotsrc_cmalloc();
char*         dotsrc_ccalloc();
void          dotsrc_cfree();
char*         dotsrc_strdup();

char*         dotsrc_dmalloc();
char*         dotsrc_dcalloc();
void          dotsrc_dfree();
void          check_memory_usage();

char*         malloc();
char*         calloc();
/** read macros **/

/* PROGRAM */

#define mread_from_program(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "program", is_program_non_NULL, MEMBER, (MACRO))
#define mread_env_def(A) mread_from_program((A), env_def, "mread_env_def")
#define mread_exp_def(A) mread_from_program((A), exp_def, "mread_exp_def")
#define mread_obj_def(A) mread_from_program((A), obj_def, "mread_obj_def")
#define mread_mod_def(A) mread_from_program((A), mod_def, "mread_mod_def")
#define mread_link_def(A) mread_from_program((A), link_def, "mread_link_def")
#define mread_rule_def(A) mread_from_program((A), rule_def, "mread_rule_def")

/* ENVDEF */

#define mread_from_env_def(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "env_def", is_env_def_non_NULL, MEMBER, (MACRO))
#define mread_name(A) mread_from_env_def((A), name, "mread_name")
#define mread_author(A) mread_from_env_def((A), author, "mread_author")
#define mread_date(A) mread_from_env_def((A), date, "mread_date")
#define mread_def_libs(A) mread_from_env_def((A), def_libs, "mread_deflibs")

/* DEFLIB */

#define mread_from_def_lib(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "def_lib", is_def_lib_non_NULL, MEMBER, (MACRO))
#define mread_lib_lab(A) \
  ((A) == NULL ? NULL \
               : ((A)->tag == DEF_LIB) \
                     ? (A)->lib_lab \
                     : (type_error((A), "def_lib", "mread_lib_lab"), \
			NULL))
#define mread_lib_names(A) mread_from_def_lib((A), lib_names,"mread_lib_names")

/* STRING */

#define mread_str_data(A) \
  mread((A), "string", is_string_non_NULL, str_data, "mread_str_data")

/* EXP_DEF */

#define mread_exps(A) \
  mread((A), "exp_def", is_exp_def_non_NULL, exps, "mread_exps")

/* EXP */

#define mread_from_exp(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "exp", is_exp_non_NULL, MEMBER, (MACRO))
#define mread_exp_name(A) mread_from_exp((A), exp_name, "mread_exp_name")
#define mread_o_term_inExp(A) mread_from_exp((A), o_term, "mread_o_term_inExp")

/* OBJ_DEF */

#define mread_from_obj_def(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "obj_def", is_obj_def_non_NULL, MEMBER, (MACRO))
#define mread_obj_subs(A) mread_from_obj_def((A), obj_subs, "mread_obj_subs")

/* OBJ_SUB */
#define mread_from_obj_sub(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "obj_sub", is_obj_sub_non_NULL, MEMBER, (MACRO))
#define mread_bobj1(A) mread_from_obj_sub((A), bobj1, "mread_bobj1")
#define mread_bobj2(A) mread_from_obj_sub((A), bobj2, "mread_bobj2")
/* MOD_DEF */

#define mread_m_subs_inModDef(A) \
  mread((A), "mod_def", is_mod_def_non_NULL, m_subs, "mread_m_subs")

/* M_SUB */

#define mread_from_m_sub(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "m_sub", is_m_sub_non_NULL, MEMBER, (MACRO))
#define mread_m_id_inMSub(A) mread_from_m_sub((A), m_id, "mread_m_id_inMSub")
#define mread_m_desc(A) mread_from_m_sub((A), m_desc, "mread_m_desc")

/* M2_DESC */

#define mread_from_m2_desc(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "m2_desc", is_m2_desc_non_NULL, MEMBER, (MACRO))
#define mread_m_desc1(A) mread_from_m2_desc((A), m_desc1, "mread_m_desc1")
#define mread_m_op(A) mread_from_m2_desc((A), op, "mread_m_desc")
#define mread_m_desc2(A) mread_from_m2_desc((A), m_desc2, "mread_m_desc2")

/* LINK_DEF */

#define mread_links(A) \
  mread((A), "link_def", is_link_def_non_NULL, links, "mread_links")

/* LINK */

#define mread_from_link(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "link", is_link_non_NULL, MEMBER, (MACRO))
#define mread_link_name(A) mread_from_link((A), link_name, "mread_link_name")
#define mread_m_ids_inLink(A) mread_from_link((A), m_ids, "mread_m_ids_inLink")
#define mread_o_terms_inLink(A) mread_from_link((A), o_terms, "mread_o_terms")

/* M_ID_PAIR */

#define mread_from_m_id_pair(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "m_id_pair", is_m_id_pair_non_NULL, MEMBER, (MACRO))
#define mread_m_id1(A) mread_from_m_id_pair((A), m_id1, "mread_m_id1")
#define mread_m_id2(A) mread_from_m_id_pair((A), m_id2, "mread_m_id2")

/* O_TERM_PAIR */

#define mread_from_o_term_pair(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "o_term_pair", is_o_term_pair_non_NULL, MEMBER, (MACRO))
#define mread_o_term1(A) mread_from_o_term_pair((A), o_term1, "mread_o_term1")
#define mread_o_term2(A) mread_from_o_term_pair((A), o_term2, "mread_o_term2")

/* RULE_DEF */

#define mread_rules(A) \
  mread((A), "rule_def", is_rule_def_non_NULL, rules, "mread_rules")

/* RULE */

#define mread_from_rule(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "rule", is_rule_non_NULL, MEMBER, (MACRO))
#define mread_rule_class(A) mread_from_rule((A), rule_class, "mread_rule_class")
#define mread_m_ids_inRule(A) mread_from_rule((A), m_ids, "mread_m_ids_inRule")
#define mread_rule_id_inRule(A) mread_from_rule((A), rule_id, "mread_rule_id")
#define mread_inheritance_mode(A) mread_from_rule((A), inheritance_mode, "mread_inheritance_mode")
#define mread_no_assume(A) mread_from_rule((A), no_assume, "mread_no_assume")
#define mread_a_term_inRule(A) mread_from_rule((A), a_term, "mread_a_term_inRule")
#define mread_clusters_inRule(A) mread_from_rule((A), clusters, "mread_clusters_inRule")
#define mread_cnstrs_inRule(A) mread_from_rule((A), cnstrs, "mread_cnstrs_inRule")

/* RULE_ID */

#define mread_rule_id_string(A) \
  mread((A), "rule_id", is_rule_id_non_NULL, rule_id_string, "mread_rule_id_string")

/* NORMAL */

#define mread_from_normal(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "normal", is_normal_non_NULL, MEMBER, (MACRO))
#define mread_m_id_inNormal(A) mread_from_normal((A), m_id, "mread_m_id_inNoramal")
#define mread_a_term_inNormal(A) mread_from_normal((A), a_term, "mread_a_term_inNormal")

/* REL */

#define mread_from_rel(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "rel", is_rel_non_NULL, MEMBER, (MACRO))
#define mread_o_term1_inRel(A) mread_from_rel((A), o_term1, "mread_o_term1_inRel")
#define mread_sub_rel_inRel(A) mread_from_rel((A), sub_rel, "mread_sub_rel_inRel")
#define mread_o_term2_inRel(A) mread_from_rel((A), o_term2, "mread_o_term2_inRel")

/* UPDATE */

#define mread_from_update(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "update", is_update_non_NULL, MEMBER, (MACRO))
#define mread_u_flag(A) mread_from_update((A), u_flag, "mread_u_flag")
#define mread_m_id_inUpdate(A) mread_from_update((A), m_id, "mread_m_id_inUpdate")
#define mread_a_term_inUpdate(A) mread_from_update((A), a_term, "mread_a_term_inUpdate")

/* TRANSACTION */

#define mread_trn_data(A) \
  mread((A), "transaction", is_transaction_non_NULL, trn_data, "mread_trn_data")

/* I_CHECK */
#define mread_i_check_content(A) \
  mread((A), "i_check", is_i_check_non_NULL, i_check_content, "mread_i_check_content")

/* PROP */

#define mread_from_prop(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "prop", is_prop_non_NULL, MEMBER, (MACRO))
#define mread_m_id_inProp(A) mread_from_prop((A), m_id, "mread_m_id_inProp")
#define mread_a_term_inProp(A) mread_from_prop((A), a_term, "mread_a_term_inProp")

/* A_TERM */

#define mread_from_a_term(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "a_term", is_a_term_non_NULL, MEMBER, (MACRO))
#define mread_o_term_inATerm(A) mread_from_a_term((A), o_term, "mread_o_term_inATerm")
#define mread_attrs_inATerm(A) mread_from_a_term((A), attrs, "mread_attrs_inATerm")
#define mread_cnstrs_inATerm(A) mread_from_a_term((A), cnstrs, "mread_cnstrs_inAterm")

 /* C_O_TERM */

#define mread_from_c_o_term(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "c_o_term", is_c_o_term_non_NULL, MEMBER, (MACRO))
#define mread_head_inCOTerm(A) mread_from_c_o_term((A), head, "mread_head_inCOTerm")
#define mread_attrs_inCOTerm(A) mread_from_c_o_term((A), attrs, "mread_attrs_inCOTerm")
#define mread_cnstrs_inCOTerm(A) mread_from_c_o_term((A), cnstrs, "mread_cnstrs_inCOterm")

/* DOT */

#define mread_from_dot(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "dot", is_dot_non_NULL, MEMBER, (MACRO))
#define mread_o_term_inDot(A) mread_from_dot((A), o_term, "mread_o_term_inDot")
#define mread_label_inDot(A) mread_from_dot((A), label, "mread_label_inDot")

/* LABEL */

#define mread_o_term_inLabel(A) \
  mread((A), "label", is_label_non_NULL, o_term, "mread_o_term_inLabel")

/* SUBLIST */

#define mread_from_sub_list(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "sub_list", is_sub_list_non_NULL, MEMBER, (MACRO))
#define mread_o_terms_inSubList(A) mread_from_sub_list((A), o_terms, "mread_o_terms_inSubList")
#define mread_remain_inSubList(A) mread_from_sub_list((A), remain, "mread_remain_inSubList")

/* EXP_NAME */

#define mread_name_inExpName(A) \
  mread((A), "exp_name", is_exp_name_non_NULL, name, "mread_name_inExpName")

/* INTEGER */

#define mread_value_inInteger(A) \
  mread((A), "integer", is_integer_non_NULL, value, "mread_value_inInteger")

/* ATTR */

#define mread_from_attr(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "attr", is_attr_non_NULL, MEMBER, (MACRO))
#define mread_label_inAttr(A) mread_from_attr((A), label, "mread_label_inAttr")
#define mread_attr_op(A) mread_from_attr((A), attr_op, "mread_attr_op")
#define mread_value_inAttr(A) mread_from_attr((A), value, "mread_value")
/** read macros **/

/* SET */
#define mread_o_terms_inSet(A) \
  mread((A), "set", is_set_non_NULL, o_terms, "mread_o_terms_inSet")

/* CNSTR_DATA */
#define mread_from_cnstr_data(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "cnstr_data", is_cnstr_data_non_NULL, MEMBER, (MACRO))
#define mread_m_id1_inCnstrData(A) \
  mread_from_cnstr_data((A), m_id1, "mread_m_id1_inCnstrData")
#define mread_value1(A) \
  mread_from_cnstr_data((A), value1, "mread_value1")
#define mread_rel_inCnstrData(A) \
  mread_from_cnstr_data((A), rel, "mread_rel_inCnstrData")
#define mread_m_id2_inCnstrData(A) \
  mread_from_cnstr_data((A), m_id2, "mread_m_id2_inCnstrData")
#define mread_value2(A) \
  mread_from_cnstr_data((A), value2, "mread_value2")

/* QUERY_CNSTR */
#define mread_from_query_cnstr(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "query_cnstr", is_query_cnstr_non_NULL, MEMBER, (MACRO))
#define mread_m_id1_inQueryCnstr(A) \
  mread_from_query_cnstr((A), m_id1, "mread_m_id1_inQueryCnstr")
#define mread_m_id2_inQueryCnstr(A) \
  mread_from_query_cnstr((A), m_id2, "mread_m_id2_inQueryCnstr")

/* PROLOG */
#define mread_from_prolog(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "prolog", is_prolog_non_NULL, MEMBER, (MACRO))
#define mread_head_inProlog(A) \
  mread_from_prolog((A), head, "mread_head_inProlog")
#define mread_o_terms_inProlog(A) \
  mread_from_prolog((A), o_terms, "mread_o_terms_inProlog")

/* VAR */
#define mread_from_var(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "var", is_var_non_NULL, MEMBER, (MACRO))
#define mread_type(A) mread_from_var((A), type, "mread_type")
#define mread_var_data(A) mread_from_var((A), var_data, "mread_var_data")

/* SORT */
#define mread_prolog(A) \
  mread((A), "sort", is_sort_non_NULL, prolog, "mread_prolog")

/* QUERY */
#define mread_from_query(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "query", is_query_non_NULL, MEMBER, (MACRO))
#define mread_query_class(A) \
  mread_from_query((A), query_class, "mread_query_class")
#define mread_q_head(A) \
  mread_from_query((A), q_head, "mread_q_head")
#define mread_clusters_inQuery(A) \
  mread_from_query((A), clusters, "mread_clusters_inQuery")
#define mread_cnstrs_inQuery(A) \
  mread_from_query((A), cnstrs, "mread_cnstrs_inQuery")
#define mread_q_modes(A) mread_from_query((A), q_modes, "mread_q_modes")
#define mread_program_inQuery(A) \
  mread_from_query((A), program, "mread_program_inQuery")

/* P_MODE */
#define mread_p_mode_data(A) \
  mread((A), "p_mode", is_p_mode_non_NULL, p_mode_data, "mread_p_mode_data")

/* A_MODE */
#define mread_a_mode_data(A) \
  mread((A), "a_mode", is_a_mode_non_NULL, a_mode_data, "mread_a_mode_data")

/* I_MODE */
#define mread_i_mode_data(A) \
  mread((A), "i_mode", is_i_mode_non_NULL, i_mode_data, "mread_i_mode_data")

/* M_MODE */
#define mread_m_mode_data(A) \
  mread((A), "m_mode", is_m_mode_non_NULL, m_mode_data, "mread_m_mode_data")

/* E_MODE */
#define mread_e_mode_data(A) \
  mread((A), "e_mode", is_e_mode_non_NULL, e_mode_data, "mread_e_mode_data")

/* ANSWER */
#define mread_answer_elements(A) \
  mread((A), "answer", is_answer_non_NULL, answer_elements, \
    "mread_answer_elements")

/* ANSWER_ELEMENT */
#define mread_from_answer_element(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "answer_element", is_answer_element_non_NULL, \
    MEMBER, (MACRO))
#define mread_dot_cnstrs(A) \
  mread_from_answer_element((A), dot_cnstrs, "mread_dot_cnstrs")
#define mread_var_cnstrs(A) \
  mread_from_answer_element((A), var_cnstrs, "mread_var_cnstrs")
#define mread_anse_explanation(A) \
  mread_from_answer_element((A), anse_explanation, "mread_anse_explanation")

/* ANSE_EXPLANATION */
#define mread_from_anse_explanation(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "anse_explanation", is_anse_explanation_non_NULL,\
  MEMBER, (MACRO))
#define mread_explanation_inAnseExplanation(A) \
  mread_from_anse_explanation((A), explanation, \
  "mread_explanation_inAnseExplanation")
#define mread_rir_pairs(A) \
  mread_from_anse_explanation((A), rir_pairs, "mread_rir_pairs")

/* RIR_PAIR */
#define mread_from_rir_pair(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "rir_pair", is_rir_pair_non_NULL, MEMBER, (MACRO))
#define mread_rule_id_inRirPair(A) \
  mread_from_rir_pair((A), rule_id, "mread_rule_id_inRirPair")
#define mread_rule(A) mread_from_rir_pair((A), rule, "mread_rule")

/* DOT_CNSTR */
#define mread_from_dot_cnstr(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "dot_cnstr", is_dot_cnstr_non_NULL, MEMBER, (MACRO))
#define mread_m_id_inDotCnstr(A) \
  mread_from_dot_cnstr((A), m_id, "mread_m_id_inDotCnstr")
#define mread_dot_inDotCnstr(A) \
  mread_from_dot_cnstr((A), dot, "mread_dot_inDotCnstr")
#define mread_rel_inDotCnstr(A) \
  mread_from_dot_cnstr((A), rel, "mread_rel_inDotCnstr")
#define mread_value_inDotCnstr(A) \
  mread_from_dot_cnstr((A), value, "mread_value_inDotCnstr")

/* VAR_CNSTR */
#define mread_from_var_cnstr(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "var_cnstr", is_var_cnstr_non_NULL, MEMBER, (MACRO))
#define mread_var_inVarCnstr(A) \
  mread_from_var_cnstr((A), var, "mread_var_inVarCnstr")
#define mread_rel_inVarCnstr(A) \
  mread_from_var_cnstr((A), rel, "mread_rel_inVarCnstr")
#define mread_value_inVarCnstr(A) \
  mread_from_var_cnstr((A), value, "mread_value_inVarCnstr")

/** read macros **/

/* INHERIT */
#define mread_from_inherit(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "inherit", is_inherit_non_NULL, MEMBER, (MACRO))
#define mread_one_rule(A) mread_from_inherit((A), one_rule, "mread_one_rule")
#define mread_ups(A) mread_from_inherit((A), ups, "mread_ups")
#define mread_downs(A) mread_from_inherit((A), downs, "mread_downs")

/* MERGE_EXPLANATION */
#define mread_unit_explanations(A) \
  mread((A), "merge_explanation", is_merge_explanation_non_NULL, \
    unit_explanations, "mread_unit_explanations")

/* LOOKUP_EXPLANATION */
#define mread_from_lookup_explanation(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "lookup_explanation", is_lookup_explanation_non_NULL, \
  MEMBER, (MACRO))
#define mread_sub_goal_inLookupExplanation(A) \
  mread_from_lookup_explanation((A), sub_goal, \
    "mread_sub_goal_inLookupExplanation")
#define mread_looked_s(A) \
  mread_from_lookup_explanation((A), looked_s, "mread_looked_s")
#define mread_looking_s(A) \
  mread_from_lookup_explanation((A), looking_s, "mread_looking_s")
#define mread_explanation_inLookupExplanation(A) \
  mread_from_lookup_explanation((A), explanation, \
    "mread_explanation_inLookupExplanation")

/* FACT */
#define mread_from_fact(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "fact", is_fact_non_NULL, MEMBER, (MACRO))
#define mread_fact_data(A) \
  mread_from_fact((A), fact_data, "mread_fact_data")

/* REDUCE */
#define mread_from_reduce(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "reduce", is_reduce_non_NULL, MEMBER, (MACRO))
#define mread_sub_goal_inReduce(A) \
  mread_from_reduce((A), sub_goal, "mread_sub_goal_inReduce")
#define mread_rule_id_inReduce(A) \
  mread_from_reduce((A), rule_id, "mread_rule_id_inReduce")
#define mread_explanations(A) \
  mread_from_reduce((A), explanations, "mread_explanations")
#define mread_assumps(A) \
  mread_from_reduce((A), assumps, "mread_assumps")

/* SUB_GOAL */
#define mread_from_sub_goal(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "sub_goal", is_sub_goal_non_NULL, MEMBER, (MACRO))
#define mread_m_id_inSubGoal(A) \
  mread_from_sub_goal((A), m_id, "mread_m_id_inSubGoal")
#define mread_o_term_inSubGoal(A) \
  mread_from_sub_goal((A), o_term, "mread_o_term_inSubGoal")
#define mread_vc_pairs_inSubGoal(A) \
  mread_from_sub_goal((A), vc_pairs, "mread_vc_pairs_inSubGoal")

/* VC_PAIR */
#define mread_from_vc_pair(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "vc_pair", is_vc_pair_non_NULL, MEMBER, (MACRO))
#define mread_var_inVcPair(A) \
  mread_from_vc_pair((A), var, "mread_var_inVcPair")
#define mread_constraint(A) \
  mread_from_vc_pair((A), constraint, "mread_constraint")

/* CONSTRAINT */
#define mread_const_data(A) \
  mread((A), "constraint", is_constraint_non_NULL, \
    const_data, "mread_const_data")

/* CON */
#define mread_from_con(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "con", is_con_non_NULL, MEMBER, (MACRO))
#define mread_o_terms1_inCon(A) \
  mread_from_con((A), o_terms1, "mread_o_terms1_inCon")
#define mread_o_terms2_inCon(A) \
  mread_from_con((A), o_terms2, "mread_o_terms2_inCon")

/* ASSUMP */
#define mread_from_assump(OBJECT, MEMBER, MACRO) \
  mread((OBJECT), "assump", is_assump_non_NULL, MEMBER, (MACRO))
#define mread_m_id_inAssump(A) \
  mread_from_assump((A), m_id, "mread_m_id_inAssump")
#define mread_dot_inAssump(A) \
  mread_from_assump((A), dot, "mread_dot_inAssump")
#define mread_vc_pairs_inAssump(A) \
  mread_from_assump((A), vc_pairs, "mread_vc_pairs_inAssump")


/** write macros **/

/* PROGRAM */

#define mwrite_env_def(A, B) \
  mwrite((A), (B), "program", is_program_non_NULL, env_def, "mwrite_env_def")
#define mwrite_exp_def(A, B) \
  mwrite((A), (B), "program", is_program_non_NULL, exp_def, "mwrite_exp_def")
#define mwrite_obj_def(A, B) \
  mwrite((A), (B), "program", is_program_non_NULL, obj_def, "mwrite_obj_def")
#define mwrite_mod_def(A, B) \
  mwrite((A), (B), "program", is_program_non_NULL, mod_def, "mwrite_mod_def")
#define mwrite_link_def(A, B) \
  mwrite((A), (B), "program", is_program_non_NULL, link_def, "mwrite_link_def")
#define mwrite_rule_def(A, B) \
  mwrite((A), (B), "program", is_program_non_NULL, rule_def, "mwrite_rule_def")

/* ENVDEF */

#define mwrite_name_inEnvDef(A, B) \
  mwrite((A), (B), "env_def", is_env_def_non_NULL, name, \
	 "mwrite_name_inEnvDef")
#define mwrite_author(A, B) \
  mwrite((A), (B), "env_def", is_env_def_non_NULL, author, "mwrite_author")
#define mwrite_date(A, B) \
  mwrite((A), (B), "env_def", is_env_def_non_NULL, date, "mwrite_date")
#define mwrite_def_libs(A, B) \
  mwrite((A), (B), "env_def", is_env_def_non_NULL, def_libs, "mwrite_def_libs")

/* DEFLIB */

#define mwrite_lib_lab(A, B) \
  mwrite((A), (B), "def_lib", is_def_lib_non_NULL, lib_lab, "mwrite_lib_lab")
#define mwrite_lib_names(A, B) \
  mwrite((A), (B), "def_lib", is_def_lib_non_NULL,lib_names,"mwrite_lib_names")

/* STRING */

#define mwrite_str_data(A, B) \
  mwrite((A), (B), "string", is_string_non_NULL, str_data, "mwrite_str_data")

/* EXP_DEF */

#define mwrite_exps(A, B) \
  mwrite((A), (B), "exp_def", is_exp_def_non_NULL, exps, "mwrite_exps")

/* EXP */

#define mwrite_exp_name(A, B) \
  mwrite((A), (B), "exp", is_exp_non_NULL, exp_name, "mwrite_exp_name")
#define mwrite_o_term_inExp(A, B) \
  mwrite((A), (B), "exp", is_exp_non_NULL, o_term, "mwrite_o_term_inExp")

/* OBJ_DEF */

#define mwrite_obj_subs(A, B) \
  mwrite((A), (B), "obj_def", is_obj_def_non_NULL, obj_subs, "mwrite_obj_subs")

/* OBJ_SUB */

#define mwrite_bobj1(A, B) \
  mwrite((A), (B), "obj_sub", is_obj_sub_non_NULL, bobj1, "mwrite_bobj1")
#define mwrite_bobj2(A, B) \
  mwrite((A), (B), "obj_sub", is_obj_sub_non_NULL, bobj2, "mwrite_bobj2")
/* MOD_DEF */

#define mwrite_m_subs_inModDef(A, B) \
  mwrite((A),(B), "mod_def", is_mod_def_non_NULL, m_subs, "mwrite_m_subs_inModDef")

/* M_SUB */

#define mwrite_m_id_inMSub(A, B)\
   mwrite((A),(B), "m_sub",is_m_sub_non_NULL, m_id, "mwrite_m_id_inMsub")
#define mwrite_m_desc(A, B)\
   mwrite((A),(B), "m_sub",is_m_sub_non_NULL,m_desc, "mwrite_m_desc")

/* M2_DESC */

#define mwrite_m_desc1(A, B)\
   mwrite((A),(B), "m2_desc",is_m2_desc_non_NULL,m_desc1,"mwrite_m_desc1")
#define mwrite_m_op(A, B)\
   mwrite((A),(B), "m2_desc",is_m2_desc_non_NULL,op,"mwrite_m_op")
#define mwrite_m_desc2(A, B)\
   mwrite((A),(B), "m2_desc",is_m2_desc_non_NULL,m_desc2,"mwrite_m_desc2")

/* LINK_DEF */

#define mwrite_links(A, B) \
  mwrite((A),(B), "link_def",is_link_def_non_NULL, links,"mwrite_links")

/* LINK */

#define mwrite_link_name(A, B)\
   mwrite((A),(B), "link",is_link_non_NULL,link_name,"mwrite_link_name")
#define mwrite_m_ids_inLink(A, B)\
   mwrite((A),(B), "link",is_link_non_NULL,m_ids,"mwrite_m_ids_inLink")
#define mwrite_o_terms_inLink(A, B)\
   mwrite((A),(B), "link",is_link_non_NULL,o_terms,"mwrite_o_terms_inLink")

/* M_ID_PAIR */

#define mwrite_m_id1(A, B)\
   mwrite((A),(B), "m_id_pair",is_m_id_pair_non_NULL,m_id1,"mwrite_m_id1")
#define mwrite_m_id2(A, B)\
   mwrite((A),(B), "m_id_pair",is_m_id_pair_non_NULL,m_id2,"mwrite_m_id2")

/* O_TERM_PAIR */

#define mwrite_o_term1(A, B)\
   mwrite((A),(B), "o_term_pair",is_o_term_pair_non_NULL,o_term1,"mwrite_o_term1")
#define mwrite_o_term2(A, B)\
   mwrite((A),(B), "o_term_pair",is_o_term_pair_non_NULL,o_term2,"mwrite_o_term2")

/* RULE_DEF */

#define mwrite_rules(A, B) \
  mwrite((A),(B), "rule_def",is_rule_def_non_NULL, rules,"mwrite_rules")

/* RULE */

#define mwrite_rule_class(A, B)\
   mwrite((A),(B), "rule",is_rule_non_NULL,rule_class,"mwrite_rule_class")
#define mwrite_m_ids_inRule(A, B)\
   mwrite((A),(B),"rule",is_rule_non_NULL, m_ids,"mwrite_m_ids_inRule")
#define mwrite_rule_id(A, B)\
   mwrite((A),(B),"rule", is_rule_non_NULL,rule_id,"mwrite_rule_id")
#define mwrite_inheritance_mode(A, B)\
   mwrite((A),(B), "rule",is_rule_non_NULL,inheritance_mode,"mwrite_inheritance_mode")
#define mwrite_no_assume(A, B)\
   mwrite((A),(B), "rule",is_rule_non_NULL,no_assume,"mwrite_no_assume")
#define mwrite_a_term_inRule(A,B)\
   mwrite((A),(B), "rule",is_rule_non_NULL,a_term,"mwrite_a_term_inRule")
#define mwrite_clusters_inRule(A, B)\
   mwrite((A),(B), "rule",is_rule_non_NULL,clusters, "mwrite_clusters_inRule")
#define mwrite_cnstrs_inRule(A, B)\
   mwrite((A),(B), "rule",is_rule_non_NULL,cnstrs,"mwrite_cnstrs_inRule")

/* RULE_ID */

#define mwrite_rule_id_string(A, B) \
  mwrite((A),(B), "rule_id",is_rule_id_non_NULL, rule_id_string,"mwrite_rule_id_string")

/* NORMAL */

#define mwrite_m_id_inNormal(A, B)\
   mwrite((A),(B), "normal",is_normal_non_NULL,m_id,"mwrite_m_id_inNormal")
#define mwrite_a_term_inNormal(A, B)\
   mwrite((A),(B), "normal", is_normal_non_NULL,a_term,"mwrite_a_term_inNormal")

/* REL */

#define mwrite_o_term1_inRel(A, B)\
   mwrite((A),(B),"rel", is_rel_non_NULL,o_term1,"mwrite_o_term1_inRel")
#define mwrite_sub_rel_inRel(A, B)\
   mwrite((A),(B), "rel",is_rel_non_NULL,sub_rel,"mwrite_sub_rel_inRel")
#define mwrite_o_term2_inRel(A, B)\
   mwrite((A),(B), "rel",is_rel_non_NULL,o_term2,"mwrite_o_term2_inRel")

/* UPDATE */

#define mwrite_u_flag(A, B)\
   mwrite((A),(B), "update",is_update_non_NULL,u_flag,"mwrite_u_flag")
#define mwrite_m_id_inUpdate(A, B)\
   mwrite((A),(B), "update",is_update_non_NULL,m_id,"mwrite_m_id_inUpdate")
#define mwrite_a_term_inUpdate(A, B)\
   mwrite((A),(B), "update",is_update_non_NULL,a_term,"mwrite_a_term_inUpdate")

/* TRANSACTION */

#define mwrite_trn_data(A, B) \
  mwrite((A),(B),"transaction",is_transaction_non_NULL, trn_data,"mwrite_trn_data")

/* I_CECHK */

#define mwrite_i_check_content(A, B) \
  mwrite((A),(B), "i_check", is_i_check_non_NULL, i_check_content, "mwrite_i_check_content")

/* PROP */

#define mwrite_m_id_inProp(A, B)\
   mwrite((A),(B), "prop",is_prop_non_NULL,m_id,"mwrite_m_id_inProp")
#define mwrite_a_term_inProp(A, B)\
   mwrite((A),(B), "prop",is_prop_non_NULL,a_term,"mwrite_a_term_inProp")

/* A_TERM */

#define mwrite_o_term_inATerm(A, B)\
   mwrite((A),(B), "a_term",is_a_term_non_NULL,o_term,"mwrite_o_term_inAterm")
#define mwrite_attrs_inATerm(A, B)\
   mwrite((A),(B), "a_term",is_a_term_non_NULL,attrs,"mwrite_attrs_inAterm")
#define mwrite_cnstrs_inATerm(A, B)\
   mwrite((A),(B), "a_term",is_a_term_non_NULL,cnstrs,"mwrite_cnstrs_inAterm")

 /* C_O_TERM */

#define mwrite_head_inCOTerm(A, B)\
   mwrite((A),(B), "c_o_term",is_c_o_term_non_NULL,head,"mwrite_head_inCOTerm")
#define mwrite_attrs_inCOTerm(A, B)\
   mwrite((A),(B), "c_o_term",is_c_o_term_non_NULL,attrs,"mwrite_attrs_inCOTerm")
#define mwrite_cnstrs_inCOTerm(A, B)\
   mwrite((A),(B), "c_o_term",is_c_o_term_non_NULL,cnstrs,"mwrite_cnstrs_inCOTerm")

/* DOT */

#define mwrite_o_term_inDot(A, B)\
   mwrite((A),(B), "dot",is_dot_non_NULL,o_term, "mwrite_o_term_inDot")
#define mwrite_label_inDot(A, B)\
   mwrite((A),(B), "dot",is_dot_non_NULL,label,"mwrite_label_inDot")

/* LABEL */

#define mwrite_o_term_inLabel(A, B) \
  mwrite((A),(B), "label",is_label_non_NULL, o_term,"mwrite_o_term_inLabel")

/* SUBLIST */

#define mwrite_o_terms_inSubList(A, B)\
   mwrite((A),(B), "sub_list",is_sub_list_non_NULL,o_terms,"mwrite_o_terms_inSubList")
#define mwrite_remain_inSubList(A, B)\
   mwrite((A),(B), "sub_list",is_sub_list_non_NULL,remain,"mwrite_remain_inSubList")

/* EXP_NAME */

#define mwrite_name_inExpName(A, B) \
  mwrite((A),(B), "exp_name",is_exp_name_non_NULL, name,"mwrite_name_inExpName")

/* INTEGER */

#define mwrite_value_inInteger(A, B) \
  mwrite((A),(B), "integer",is_integer_non_NULL, value,"mwrite_value_inInteger")

/* ATTR */

#define mwrite_label_inAttr(A, B)\
   mwrite((A),(B), "attr",is_attr_non_NULL,label,"mwrite_label_inAttr")
#define mwrite_attr_op(A, B)\
   mwrite((A),(B), "attr",is_attr_non_NULL,attr_op,"mwrite_attr_op")
#define mwrite_value_inAttr(A, B)\
   mwrite((A),(B), "attr",is_attr_non_NULL,value,"mwrite_value")
/** write macros **/

/* SET */
#define mwrite_o_terms_inSet(A, B) \
  mwrite((A), (B), "set", is_set_non_NULL, o_terms, "mwrite_o_terms_inSet")

/* CNSTR_DATA */
#define mwrite_m_id1_inCnstrData(A, B) \
  mwrite((A), (B), "cnstr_data", is_cnstr_data_non_NULL, m_id1, \
	 "mwrite_m_id1_inCnstrData")
#define mwrite_value1(A, B) \
  mwrite((A), (B), "cnstr_data", is_cnstr_data_non_NULL, value1, \
	 "mwrite_value1")
#define mwrite_rel_inCnstrData(A, B) \
  mwrite((A), (B), "cnstr_data", is_cnstr_data_non_NULL, rel, \
	 "mwrite_rel_inCnstrData")
#define mwrite_m_id2_inCnstrData(A, B) \
  mwrite((A), (B), "cnstr_data", is_cnstr_data_non_NULL, m_id2, \
	 "mwrite_m_id2_inCnstrData")
#define mwrite_value2(A, B) \
  mwrite((A), (B), "cnstr_data", is_cnstr_data_non_NULL, value2, \
	 "mwrite_value2")

/* QUERY_CNSTR */
#define mwrite_m_id1_inQueryCnstr(A, B) \
  mwrite((A), (B), "query_cnstr", is_query_cnstr_non_NULL, m_id1, \
	 "mwrite_m_id1_inQueryCnstr")
#define mwrite_m_id2_inQueryCnstr(A, B) \
  mwrite((A), (B), "query_cnstr", is_query_cnstr_non_NULL, m_id2, \
	 "mwrite_m_id2_inQueryCnstr")

/* PROLOG */
#define mwrite_head_inProlog(A, B) \
  mwrite((A), (B), "prolog", is_prolog_non_NULL, head, \
	 "mwrite_head_inProlog")
#define mwrite_o_terms_inProlog(A, B) \
  mwrite((A), (B), "prolog", is_prolog_non_NULL, o_terms, \
	 "mwrite_o_terms_inProlog")

/* VAR */
#define mwrite_type(A, B) \
  mwrite((A), (B), "var", is_var_non_NULL, type, "mwrite_type")
#define mwrite_var_data(A, B) \
  mwrite((A), (B), "var", is_var_non_NULL, var_data, "mwrite_var_data")

/* SORT */
#define mwrite_prolog(A, B) \
  mwrite((A), (B), "sort", is_sort_non_NULL, prolog, "mwrite_prolog")

/* QUERY */
#define mwrite_query_class(A, B) \
  mwrite((A), (B), "query", is_query_non_NULL, query_class, \
	 "mwrite_query_class")
#define mwrite_q_head(A, B) \
  mwrite((A), (B), "query", is_query_non_NULL, q_head, "mwrite_q_head")
#define mwrite_clusters_inQuery(A, B) \
  mwrite((A), (B), "query", is_query_non_NULL, clusters, \
	 "mwrite_clusters_inQuery")
#define mwrite_cnstrs_inQuery(A, B) \
  mwrite((A), (B), "query", is_query_non_NULL, cnstrs, "mwrite_cnstrs_inQuery")
#define mwrite_q_modes(A, B) \
  mwrite((A), (B), "query", is_query_non_NULL, q_modes, "mwrite_q_modes")
#define mwrite_program_inQuery(A, B) \
  mwrite((A), (B), "query", is_query_non_NULL, program, \
	 "mwrite_program_inQuery")

/* P_MODE */
#define mwrite_p_mode_data(A, B) \
  mwrite((A), (B), "p_mode", is_p_mode_non_NULL, p_mode_data, \
    "mwrite_p_mode_data")

/* A_MODE */
#define mwrite_a_mode_data(A, B) \
  mwrite((A), (B), "a_mode", is_a_mode_non_NULL, a_mode_data, \
    "mwrite_a_mode_data")

/* I_MODE */
#define mwrite_i_mode_data(A, B) \
  mwrite((A), (B), "i_mode", is_i_mode_non_NULL, i_mode_data, \
    "mwrite_i_mode_data")

/* M_MODE */
#define mwrite_m_mode_data(A, B) \
  mwrite((A), (B), "m_mode", is_m_mode_non_NULL, m_mode_data, \
    "mwrite_m_mode_data")

/* E_MODE */
#define mwrite_e_mode_data(A, B) \
  mwrite((A), (B), "e_mode", is_e_mode_non_NULL, e_mode_data, \
    "mwrite_e_mode_data")

/* ANSWER */
#define mwrite_answer_elements(A, B) \
  mwrite((A), (B), "answer", is_answer_non_NULL, answer_elements, \
    "mwrite_answer_elements")

/* ANSWER_ELEMENT */
#define mwrite_dot_cnstrs(A, B) \
  mwrite((A), (B), "answer_element", is_answer_element_non_NULL, dot_cnstrs, \
	 "mwrite_dot_cnstrs")
#define mwrite_var_cnstrs(A, B) \
  mwrite((A), (B), "answer_element", is_answer_element_non_NULL, var_cnstrs, \
	 "mwrite_var_cnstrs")
#define mwrite_anse_explanation(A, B) \
  mwrite((A), (B), "answer_element", is_answer_element_non_NULL, \
	 anse_explanation, "mwrite_anse_explanation")

/* ANSE_EXPLANATION */
#define mwrite_explanation_inAnseExplanation(A, B) \
  mwrite((A), (B), "anse_explanation", is_anse_explanation_non_NULL, \
	 explanation, "mwrite_explanation_inAnseExplanation")
#define mwrite_rir_pairs(A, B) \
  mwrite((A), (B), "anse_explanation", is_anse_explanation_non_NULL, \
	 rir_pairs, "mwrite_rir_pairs")

/* RIR_PAIR */
#define mwrite_rule_id_inRirPair(A, B) \
  mwrite((A), (B), "rir_pair", is_rir_pair_non_NULL, rule_id, \
	 "mwrite_rule_id_inRirPair")
#define mwrite_rule(A, B) \
  mwrite((A), (B), "rir_pair", is_rir_pair_non_NULL, rule, "mwrite_rule")

/* DOT_CNSTR */
#define mwrite_m_id_inDotCnstr(A, B) \
  mwrite((A), (B), "dot_cnstr", is_dot_cnstr_non_NULL, m_id, \
         "mwrite_m_id_inDotCnstr")
#define mwrite_dot_inDotCnstr(A, B) \
  mwrite((A), (B), "dot_cnstr", is_dot_cnstr_non_NULL, dot, \
         "mwrite_dot_inDotCnstr")
#define mwrite_rel_inDotCnstr(A, B) \
  mwrite((A), (B), "dot_cnstr", is_dot_cnstr_non_NULL, rel, \
         "mwrite_rel_inDotCnstr")
#define mwrite_value_inDotCnstr(A, B) \
  mwrite((A), (B), "dot_cnstr", is_dot_cnstr_non_NULL, value, \
         "mwrite_value_inDotCnstr")

/* VAR_CNSTR */
#define mwrite_var_inVarCnstr(A, B) \
  mwrite((A), (B), "var_cnstr", is_var_cnstr_non_NULL, var, \
	 "mwrite_var_inVarCnstr")
#define mwrite_rel_inVarCnstr(A, B) \
  mwrite((A), (B), "var_cnstr", is_var_cnstr_non_NULL, rel, \
	 "mwrite_rel_inVarCnstr")
#define mwrite_value_inVarCnstr(A, B) \
  mwrite((A), (B), "var_cnstr", is_var_cnstr_non_NULL, value, \
	 "mwrite_value_inVarCnstr")

/** write macros **/

/* INHERIT */
#define mwrite_one_rule(A, B) \
  mwrite((A), (B), "inherit", is_inherit_non_NULL, one_rule, "mwrite_one_rule")
#define mwrite_ups(A, B) \
  mwrite((A), (B), "inherit", is_inherit_non_NULL, ups, "mwrite_ups")
#define mwrite_downs(A, B) \
  mwrite((A), (B), "inherit", is_inherit_non_NULL, downs, "mwrite_downs")

/* MERGE_EXPLANATION */
#define mwrite_unit_explanations(A, B) \
  mwrite((A), (B), "merge_explanation", is_merge_explanation_non_NULL, \
    unit_explanations, "mwrite_unit_explanations")

/* LOOKUP_EXPLANATION */
#define mwrite_sub_goal_inLookupExplanation(A, B) \
  mwrite((A), (B), "lookup_explanation", is_lookup_explanation_non_NULL, \
	 sub_goal, "mwrite_sub_goal_inLookupExplanation")
#define mwrite_looked_s(A, B) \
  mwrite((A), (B), "lookup_explanation", is_lookup_explanation_non_NULL, \
	 looked_s, "mwrite_looked_s")
#define mwrite_looking_s(A, B) \
  mwrite((A), (B), "lookup_explanation", is_lookup_explanation_non_NULL, \
	 looking_s, "mwrite_looking_s")
#define mwrite_explanation_inLookupExplanation(A, B) \
  mwrite((A), (B), "lookup_explanation", is_lookup_explanation_non_NULL, \
	 explanation, "mwrite_explanation_inLookupExplanation")

/* FACT */
#define mwrite_fact_data(A, B) \
  mwrite((A), (B), "fact", is_fact_non_NULL, fact_data, "mwrite_fact_data")

/* REDUCE */
#define mwrite_sub_goal_inReduce(A, B) \
  mwrite((A), (B), "reduce", is_reduce_non_NULL, sub_goal, \
	 "mwrite_sub_goal_inReduce")
#define mwrite_rule_id_inReduce(A, B) \
  mwrite((A), (B), "reduce", is_reduce_non_NULL, rule_id, \
	 "mwrite_rule_id_inReduce")
#define mwrite_explanations(A, B) \
  mwrite((A), (B), "reduce", is_reduce_non_NULL, explanations, \
	 "mwrite_explanations")
#define mwrite_assumps(A, B) \
  mwrite((A), (B), "reduce", is_reduce_non_NULL, assumps, "mwrite_assumps")

/* SUB_GOAL */
#define mwrite_m_id_inSubGoal(A, B) \
  mwrite((A), (B), "sub_goal", is_sub_goal_non_NULL, m_id, \
	 "mwrite_m_id_inSubGoal")
#define mwrite_o_term_inSubGoal(A, B) \
  mwrite((A), (B), "sub_goal", is_sub_goal_non_NULL, o_term, \
	 "mwrite_o_term_inSubGoal")
#define mwrite_vc_pairs_inSubGoal(A, B) \
  mwrite((A), (B), "sub_goal", is_sub_goal_non_NULL, vc_pairs, \
	 "mwrite_vc_pairs_inSubGoal")

/* VC_PAIR */
#define mwrite_var_inVcPair(A, B) \
  mwrite((A), (B), "vc_pair", is_vc_pair_non_NULL, var, "mwrite_var_inVcPair")
#define mwrite_constraint(A, B) \
  mwrite((A), (B), "vc_pair", is_vc_pair_non_NULL, constraint, \
	 "mwrite_constraint")

/* CONSTRAINT */
#define mwrite_const_data(A, B) \
  mwrite((A), (B), "constraint", is_constraint_non_NULL, \
	 const_data, "mwrite_const_data")

/* CON */
#define mwrite_o_terms1_inCon(A, B) \
  mwrite((A), (B), "con", is_con_non_NULL, o_terms1, "mwrite_o_terms1_inCon")
#define mwrite_o_terms2_inCon(A, B) \
  mwrite((A), (B), "con", is_con_non_NULL, o_terms2, "mwrite_o_terms2_inCon")

/* ASSUMP */
#define mwrite_m_id_inAssump(A, B) \
  mwrite((A), (B), "assump", is_assump_non_NULL, m_id, "mwrite_m_id_inAssump")
#define mwrite_dot_inAssump(A, B) \
  mwrite((A), (B), "assump", is_assump_non_NULL, dot, "mwrite_dot_inAssump")
#define mwrite_vc_pairs_inAssump(A, B) \
  mwrite((A), (B), "assump", is_assump_non_NULL, vc_pairs, \
	 "mwrite_vc_pairs_inAssump")



/** external function declarations **/

#define print_consis(A,B,C)   print_i_check(A,B,C)
#define print_inconsis(A,B,C) print_i_check(A,B,C)

#define print_ind_lab(A,B,C)  print_label(A,B,C)
#define print_set_lab(A,B,C)  print_label(A,B,C)
#define print_curl_ind(A,B,C) print_label(A,B,C)
#define print_curl_set(A,B,C) print_label(A,B,C)

/*
 .src $B$N(B access $B4X?t(B/macro

$B!!$3$3$G;H$o$l$k5-9f$O!"0J2<$N5,B'$K$7$?$,$C$F$$$k!#(B

<name>    $B%*%V%8%'%/%HJ6$$$NL>A0(B
<object>  $B%*%V%8%'%/%HJ6$$$N9=B$BN$X$N%]%$%s%?(B
<memberp> $B%*%V%8%'%/%HJ6$$$N9=@.MWAG$r3JG<$G$-$k%a%b%jNN0h$X$N%]%$%s%?(B

$B!!4X?t(B/macro $BL>$O0J2<$N5,B'$K=>$C$F$$$k!#(B

$B!}(B $B$9$Y$F$N%*%V%8%'%/%HJ6$$$K$D$$$F$N4X?t(B/macro
 (1) Bool  fis_<name>(<object>)
   $B!&5!G=(B  $B0z?t$N9=B$BN$K$h$j<($5$l$k%G!<%?$,!"L>A0$G<($5$l$k%*%V%8%'(B
           $B%/%HJ6$$$N%G!<%?$+$I$&$+D4$Y$k4X?t!#(B

 (2) Bool  is_<name>(<object>)
   $B!&5!G=(B  $B0z?t$N9=B$BN$K$h$j<($5$l$k%G!<%?$,!"L>A0$G<($5$l$k%*%V%8%'(B
           $B%/%HJ6$$$N%G!<%?$+$I$&$+D4$Y$k%^%/%m!#(B

$B!}(B $B%*%V%8%'%/%HJ6$$$N%G!<%?$,9=B$BN$N$b$N$K$D$$$F$N4X?t(B
 (1) void  decompose_<name>(<object>, <memberp1>, <memberp2>, ...)
   $B!&5!G=(B  <name> $B$N9=@.MWAG$NCM$rF@$k4X?t!#(B

 (2) $B%a%s%PL>$N%a%s%P$N7?(B  read_$B9=B$BN$N%a%s%PL>(B($B9=B$BN$X$N%]%$%s%?(B)
   $B!&5!G=(B  $B9=B$BN$N%a%s%PL>$NCM$rF@$k4X?t!#(B

 (3) $B%a%s%PL>$N%a%s%P$N7?(B  mread_$B9=B$BN$N%a%s%PL>(B($B9=B$BN$X$N%]%$%s%?(B)
   $B!&5!G=(B  $B9=B$BN$N%a%s%PL>$NCM$rF@$k%^%/%m!#(B

 (4) $B9=B$BN$N%]%$%s%?7?(B  create_$B9=B$BNL>(B($B%a%s%P$K%;%C%H$9$kCM(B,....)
   $B!&5!G=(B  $B9=B$BNL>$N9=B$BN$r?7$7$/$D$/$j!"3F%a%s%P$r0z?t$G;XDj$7$?(B
           $BCM$G=i4|2=$9$k4X?t!#(B

 (5) $B9=B$BN$N%]%$%s%?7?(B  copy_$B9=B$BNL>(B($B9=B$BN$X$N%]%$%s%?(B)
   $B!&5!G=(B  $B0z?t$G<($5$l$k9=B$BN$r%3%T!<$9$k4X?t!#(B

 (6) void  set_$B9=B$BNL>(B($B9=B$BN$X$N%]%$%s%?(B,$B%a%s%P$K%;%C%H$9$kCM(B,....)
   $B!&5!G=(B  $B0z?t$G;XDj$7$?!"9=B$BN$N9=B$BN$N3F%a%s%P$r0z?t$G;XDj$7$?(B
           $BCM$K$9$k4X?t!#(B

 (7) void  write_$B9=B$BN$N%a%s%PL>(B($B9=B$BN$X$N%]%$%s%?(B,$B%a%s%P$K%;%C%H$9$kCM(B)
   $B!&5!G=(B  $B0z?t$G;XDj$7$?!"9=B$BN$N9=B$BN$N%a%s%PL>$N%a%s%P$r0z?t$G(B
           $B;XDj$7$?CM$K$9$k4X?t!#(B

 (8) void  mwrite_$B9=B$BN$N%a%s%PL>(B($B9=B$BN$X$N%]%$%s%?(B,$B%a%s%P$K%;%C%H$9$kCM(B)
   $B!&5!G=(B  $B0z?t$G;XDj$7$?!"9=B$BN$N9=B$BN$N%a%s%PL>$N%a%s%P$r0z?t$G(B
           $B;XDj$7$?CM$K$9$k%^%/%m!#(B

 (9) $B9=B$BN$N%]%$%s%?7?(B   new_<name>()
   $B!&5!G=(B  $B?7$7$/%*%V%8%'%/%HJ6$$$r:n$j!"MWAG$r(B NULL $B$G=i4|2=$9$k4X?t(B

(10) void  delete_<name>(<object>)
   $B!&5!G=(B  $B%*%V%8%'%/%HJ6$$$r9=B$BNL>$N9=B$BN$r(B free $B$9$k!#(B

(11) void  insert_$B9=B$BN$N%a%s%PL>(B($B9=B$BN$X$N%]%$%s%?(B,
                                   $B$D$J$0%j%9%H%G!<%?$X$N%]%$%s%?(B)
   $B!&5!G=(B  $B9=B$BN$N%a%s%PL>$N%G!<%?$N@hF,$K!"Bh#20z?t$G<($5$l$?%G!<(B
           $B%?$r$D$J$0(B

(12) void  add_$B9=B$BN$N%a%s%PL>(B($B9=B$BN$X$N%]%$%s%?(B,
                                $B$D$J$0%j%9%H%G!<%?$X$N%]%$%s%?(B)
   $B!&5!G=(B  $B9=B$BN$N%a%s%PL>$N%G!<%?$N:G8e$K!"Bh#20z?t$G<($5$l$?%G!<(B
           $B%?$r$D$J$0(B

$B!}(B $B%*%V%8%'%/%HJ6$$$N%G!<%?$,6&MQBN$N$b$N$K$D$$$F$N4X?t(B
 (1) $B6&MQBN$N%]%$%s%?7?(B
       create_<name>_$B6&MQBN$N%a%s%P!<L>(B(
                    $B6&MQBN$K%;%C%H$9$k%G!<%?$NF~$C$?9=B$BN$X$N%]%$%s%?(B)
   $B!&5!G=(B  $B6&MQBN$r?7$7$/:n$j!"4X?tL>$N%a%s%P!<$K0z?t$G<($5$l$?%G!<(B
           $B%?$r%;%C%H$9$k!#(B
           $BBhFs0z?t$G<($5$l$k%G!<%?$O6&MQBN$X$N%;%C%H8e(B free $B$5$l$k!#(B

 (2) $B6&MQBN$N%]%$%s%?7?(B   copy_<name>(<object>)
   $B!&5!G=(B  <object> $B$N6&MQBN$r(B copy $B$9$k!#(B

 (3) $B6&MQBN$N%]%$%s%?7?(B   new_<name>()
   $B!&5!G=(B  <name> $B$N6&MQBN$r?7$7$/:n$j!"(BNULL $B$G=i4|2=$9$k!#(B

 (4) void  delete_<name>(<object>)
   $B!&5!G=(B  <name> $B$N6&MQBN$r(B free $B$9$k!#(B

/*
$B!|(B Program
$B!~(B $Program $B$N(B access $B4X?t(B
*/
Bool fis_program(/* PseudoObject* */);
void decompose_program(/* Program*, EnvDef**, ExpDef**, ObjDef**,
			  ModDef**, LinkDef**, RuleDef** */);
EnvDef* read_env_def(/* Program* */);
ExpDef* read_exp_def(/* Program* */);
ObjDef* read_obj_def(/* Program* */);
ModDef* read_mod_def(/* Program* */);
LinkDef* read_link_def(/* Program* */);
RuleDef* read_rule_def(/* Program* */);
Program* new_program();
Program* set_program(/* Program*, EnvDef*, ExpDef*, ObjDef*, ModDef*,
			LinkDef*, RuleDef* */);
Program* create_program(/* EnvDef*, ExpDef*, ObjDef*, ModDef*,
			   LinkDef*, RuleDef* */);
Program* write_env_def(/* Program*, EnvDef* */);
Program* write_exp_def(/* Program*, ExpDef* */);
Program* write_obj_def(/* Program*, ObjDef* */);
Program* write_mod_def(/* Program*, ModDef* */);
Program* write_link_def(/* Program*, LinkDef* */);
Program* write_rule_def(/* Program*, RuleDef* */);
void delete_program(/* Program* */);
Program* copy_program(/* Program* */);

/*
$B!|(B Env_def
$B!~(B $Env_def $B$N(B access $B4X?t(B
*/
Bool fis_env_def(/* PseudoObject* */);
void decompose_env_def(/* EnvDef*, char**, char**, char**, ObjList* */);
/* char** name, char** author, char** date */
char* read_name(/* EnvDef* env_def */);
char* read_author(/* EnvDef* env_def */);
char* read_date(/* EnvDef* env_def */);
ObjList* read_def_libs(/* EnvDef* */);
EnvDef* new_env_def();
EnvDef* set_env_def(/* EnvDef*, char *, char *, char *, ObjList* */);
/* char* name, char* author, char* date */
EnvDef* create_env_def(/* char *, char *, char *, ObjList* */);
/* char* name, char* author, char* date */
EnvDef* write_name_inEnvDef(/* EnvDef*, char* */);
EnvDef* write_author(/* EnvDef*, char* */);
EnvDef* write_date(/* EnvDef*, char* */);
EnvDef* write_def_libs(/* EnvDef*, ObjList* */);
EnvDef* insert_def_libs(/* EnvDef*, ObjList* */);
EnvDef* add_def_libs(/* EnvDef*, ObjList* */);
DefLib* car_of_def_libs(/* EnvDef* */);
void delete_env_def(/* EnvDef* */);
EnvDef* copy_env_def(/* EnvDef* */);

/*
$B!~(B $Def_lib $B$N(B access $B4X?t(B
*/
Bool fis_def_lib(/* PseudoObject* */);
void decompose_def_lib(/* DefLib*, LibLab*, ObjList** */);
LibLab read_lib_lab(/* DefLib* */);
ObjList* read_lib_names(/* DefLib* */);
DefLib* new_def_lib();
DefLib* set_def_lib(/* DefLib*, LibLab*, ObjList* */);
DefLib* create_def_lib(/* LibLab, ObjList* */);
DefLib* write_lib_lab(/* DefLib*, LibLab */);
DefLib* write_lib_names(/* DefLib*, ObjList* */);
DefLib* insert_lib_names(/* DefLib*, ObjList* */);
DefLib* add_lib_names(/* DefLib*, ObjList* */);
String* car_of_lib_names(/* DefLib* */);
void delete_def_lib(/* DefLib* */);
DefLib* copy_def_lib(/* DefLib* */);

Bool fis_string(/* PseudoObject* */);
void decompose_string(/* String*, char** */);
char* read_str_data(/* String* */);
String* new_string();
String* set_string(/* String*, char* */);
String* create_string(/* char* */);
String* write_str_data(/* String*, char* */);
void delete_string(/* String* */);
String* copy_string(/* String* */);

Bool fis_exp_def(/* PseudoObject* */);
void decompose_exp_def(/* ExpDef*, ObjList** */);
ObjList* read_exps(/* ExpDef* */);
ExpDef* new_exp_def();
ExpDef* set_exp_def(/* ExpDef*, ObjList* */);
ExpDef* create_exp_def(/* ObjList* */);
ExpDef* write_exps(/* ExpDef*, ObjList* */);
ExpDef* insert_exps(/* ExpDef*, ObjList* */);
ExpDef* add_exps(/* ExpDef*, ObjList* */);
Exp* car_of_exps(/* ExpDef* */);
void delete_exp_def(/* ExpDef* */);
ExpDef* copy_exp_def(/* ExpDef* */);

Bool fis_exp(/* PseudoObject* */);
void decompose_exp(/* Exp*, ExpName**, OTerm** */);
ExpName* read_exp_name(/* Exp* */);
OTerm* read_o_term_inExp(/* Exp* */);
Exp* new_exp();
Exp* set_exp(/* Exp*, ExpName*, OTerm* */);
Exp* create_exp(/* ExpName*, OTerm* */);
Exp* write_exp_name(/* Exp*, ExpName* */);
Exp* write_o_term_inExp(/* Exp*, OTerm* */);
void delete_exp(/* Exp* */);
Exp* copy_exp(/* Exp* */);

Bool fis_obj_def(/* PseudoObject* */);
void decompose_obj_def(/* ObjDef*, ObjList* */);
ObjList* read_obj_subs(/* ObjDef* */);
ObjDef* new_obj_def();
ObjDef* set_obj_def(/* ObjDef*, ObjList* */);
ObjDef* create_obj_def(/* ObjList* */);
ObjDef* write_obj_subs(/* ObjDef*, ObjList* */);
ObjDef* insert_obj_subs(/* ObjDef*, ObjList* */);
ObjDef* add_obj_subs(/* ObjDef*, ObjList* */);
ObjSub* car_of_obj_subs(/* ObjDef* */);
void delete_obj_def(/* ObjDef* */);
ObjDef* copy_obj_def(/* ObjDef* */);

Bool fis_obj_sub(/* PseudoObject* */);
void decompose_obj_sub(/* ObjSub*, char**, char** */);
char* read_bobj1(/* ObjSub* */);
char* read_bobj2(/* ObjSub* */);
ObjSub* new_obj_sub();
ObjSub* set_obj_sub(/* ObjSub*, char*, char* */);
ObjSub* create_obj_sub(/* char*, char* */);
ObjSub* write_bobj1(/* ObjSub*, char* */);
ObjSub* write_bobj2(/* ObjSub*, char* */);
void delete_obj_sub(/* ObjSub* */);
ObjSub* copy_obj_sub(/* ObjSub* */);

Bool fis_obj_list(/* PseudoObject*, TypeDescriptor */);
Bool fis_any_obj_list(/* PseudoObject* */);
Bool fis_obj_list_non_NULL(/* PseudoObject*, TypeDescriptor */);
ObjList* new_obj_list(/* TypeDescriptor */);
PseudoObject* extract_first_list_element(/* ObjList* */);
PseudoObject* extract_last_list_element(/* OjbList* */);
ObjList* cons_to_obj_list(/* ObjList*, PseudoObject* */);
ObjList* append_to_obj_list(/* OjbList*, PseudoObject* */);
ObjList* insert_list_to_obj_list(/* ObjList*, ObjList* */);
ObjList* concat_list_to_obj_list(/* ObjList*, ObjList* */);
void delete_obj_list(/* ObjList* */);
ObjList* copy_obj_list(/* ObjList* */);

Bool fis_obj_array(/* PseudoObject*, TypeDescriptor */);
Bool fis_any_obj_array(/* PseudoObject* */);
Bool fis_obj_array_non_NULL(/* PseudoObject*, TypeDescriptor */);
ObjArray* new_obj_array(/* TypeDescriptor, size_t */);
ObjArray* compose_obj_array(/* TypeDescriptor, int, PseudoObject** */);
ObjArray* new_empty_obj_array();
size_t array_size(/* ObjArray* */);
ObjArray* change_array_size(/* ObjArray*, int, size_t */);
ObjArray* change_array_size_deleting(/* ObjArray*, int, size_t */);
PseudoObject* read_array_element(/* ObjArray*, int */);
ObjArray* set_array_element(/* ObjArray*, int, PseudoObject* */);
ObjArray* set_array_element_deleting(/* ObjArray*, int, PseudoObject* */);
PseudoObject* set_array_element_and_return_old(/* ObjArray*, int, */
					       /* PseudoObject* */);
void delete_obj_array(/* ObjArray* */);
ObjArray* copy_obj_array(/* ObjArray* */);
ObjArray* list2array(/* ObjList* */);
ObjList* array2list(/* ObjArray* */);
/******* functions *******/
/*   mod_def */
Bool              fis_mod_def();
void              decompose_mod_def();
ModDef*           create_mod_def();
ModDef*           copy_mod_def();
ModDef*           set_mod_def();
ModDef*           new_mod_def();
ModDef*           insert_m_subs();
ModDef*           add_m_subs();
MSub*             car_of_m_subs();
void              delete_mod_def();

/*  m_sub  */
Bool              fis_m_sub();
void              decompose_m_sub();
MId*              read_m_id_inMSub();
MDesc*            read_m_desc();
MSub*             create_m_sub();
MSub*             copy_m_sub();
MSub*             set_m_sub();
MSub*             write_m_id_inMSub();
MSub*             write_m_desc();
MSub*             new_m_sub();
void              delete_m_sub();

/* m_desc */
Bool              fis_m_desc();
MDesc*            create_m_desc_m_id();
MDesc*            create_m_desc_m2_desc();
MDesc*            new_m_desc();
MDesc*            copy_m_desc();
void              delete_m_desc();

/*  m2_desc */
Bool              fis_m2_desc();
void              decompose_m2_desc();
MDesc*            read_m_desc1();
char              read_op();
MDesc*            read_m_desc2();
M2Desc*           create_m2_desc();
M2Desc*           copy_m2_desc();
M2Desc*           set_m2_desc();
M2Desc*           write_m_desc1();
M2Desc*           write_op();
M2Desc*           write_m_desc2();
M2Desc*           new_m2_desc();
void              delete_m2_desc();

/*  link_def  */
Bool              fis_link_def();
void              decompose_link_def();
LinkDef*          create_link_def();
LinkDef*          copy_link_def();
LinkDef*          set_link_def();
LinkDef*          new_link_def();
LinkDef*          insert_links();
Link*             car_of_links();
LinkDef*          add_links();
void              delete_link_def();

/*  link  */
Bool              fis_link();
void              decompose_link();
char*             read_link_name();
ObjList*          read_m_ids_inLink();
ObjList*          read_o_terms_inLink();
Link*             create_link();
Link*             copy_link();
Link*             set_link();
Link*             write_link_name();
Link*             write_m_ids_inLink();
Link*             write_o_terms_inLink();
Link*             new_link();
Link*             insert_m_ids_inLink();
Link*             insert_o_terms_inLink();
Link*             add_m_ids_inLink();
Link*             add_o_terms_inLink();
MId*              car_of_m_ids_inLink();
OTerm*            car_of_o_terms_inLink();
void              delete_link();

/*  m_id_pair */
Bool              fis_m_id_pair();
void              decompose_m_id_pair();
MId*              read_m_id1();
MId*              read_m_id2();
MIdPair*          create_m_id_pair();
MIdPair*          copy_m_id_pair();
MIdPair*          set_m_id_pair();
MIdPair*          write_m_id1();
MIdPair*          write_m_id2();
MIdPair*          new_m_id_pair();
void              delete_m_id_pair();

/*  o_term_pair */
Bool              fis_o_term_pair();
void              decompose_o_term_pair();
OTerm*            read_o_term1();
OTerm*            read_o_term2();
OTermPair*        create_o_term_pair();
OTermPair*        copy_o_term_pair();
OTermPair*        set_o_term_pair();
OTermPair*        write_o_term1();
OTermPair*        write_o_term2();
OTermPair*        new_o_term_pair();
void              delete_o_term_pair();

/*  rule_def  */
Bool              fis_rule_def();
void              decompose_rule_def();
RuleDef*          create_rule_def();
RuleDef*          copy_rule_def();
RuleDef*          set_rule_def();
RuleDef*          new_rule_def();
RuleDef*          insert_rules();
RuleDef*          add_rules();
Rule*             car_of_rules();
void              delete_rule_def();

/*  rule  */
Bool              fis_rule();
void              decompose_rule();
RuleClass         read_rule_class();
ObjList*          read_m_ids_inRule();
RuleId*           read_rule_id_inRule();
InheritanceMode   read_inheritance_mode();
NoAssume          read_no_assume();
ATerm*            read_head_inRule();
ObjList*          read_clusters_inRule();
ObjList*          read_cnstrs_inRule();
Rule*             create_rule();
Rule*             copy_rule();
Rule*             set_rule();
Rule*             write_rule_class();
Rule*             write_m_ids_inRule();
Rule*             write_rule_id_inRule();
Rule*             write_inheritance_mode_inRule();
Rule*             write_no_assume_inRule();
Rule*             write_head_inRule();
Rule*             write_clusters_inRule();
Rule*             write_cnsters_inRule();
Rule*             insert_m_ids_inRule();
Rule*             insert_clusters_inRule();
Rule*             insert_cnstrs_inRule();
Rule*             add_m_ids_inRule();
Rule*             add_clusters_inRule();
Rule*             add_cnstrs_inRule();
MId*              car_of_m_ids_inRule();
Cluster*          car_of_clusters_inRule();
Cnstr*            car_of_cnstrs_inRule();
Rule*             new_rule();
void              delete_rule();

/*  rule_id  */
Bool              fis_rule_id();
void              decompose_rule_id();
RuleId*           create_rule_id();
RuleId*           copy_rule_id();
RuleId*           set_rule_id();
RuleId*           new_rule_id();
void              delete_rule_id();

/*  cluster  */
Bool              fis_cluster();
Cluster*          create_cluster_normal();
Cluster*          create_cluster_rel();
Cluster*          create_cluster_update();
Cluster*          create_cluster_transaction();
Cluster*          create_cluster_consis();
Cluster*          create_cluster_inconsis();
Cluster*          copy_cluster();
Cluster*          new_cluster();
void              delete_cluster();

/*   normal  */
Bool              fis_normal();
Normal*           create_normal();
MId*              read_m_id_inNormal();
ATerm*            read_a_term_inNormal();
Normal*           copy_normal();
Normal*           set_normal();
Normal*           write_m_id_inNormal();
Normal*           write_a_term_inNormal();
Normal*           new_normal();
void              delete_normal();

/*  rel  */
Bool              fis_rel();
void              decompose_rel();
OTerm*            read_o_term1_inRel();
CnRel             read_sub_rel_inRel();
OTerm*            read_o_term2_inRel();
Rel*              create_rel();
Rel*              copy_rel();
Rel*              set_rel();
Rel*              write_o_term1_inRel();
Rel*              write_sub_rel_inRel();
Rel*              write_o_term2_inRel();
Rel*              new_rel();
void              delete_rel();

/*  update */
Bool              fis_update();
void              decompose_update();
UFlag             read_u_flag();
MId*              read_m_id_inUpdate();
ATerm*            read_a_term_inUpdate();
Update*           create_update();
Update*           copy_update();
Update*           set_update();
Update*           write_u_flag();
Update*           write_m_id_inUpdate();
Update*           write_a_term_inUpdate();
Update*           new_update();
void              delete_update();

/*  transaction  */
Bool              fis_transaction();
void              decompose_transaction();
Transaction*      create_transaction();
Transaction*      copy_transaction();
Transaction*      set_transaction();
Transaction*      new_transaction();
void              delete_transaction();

/*  i_check_content  */
Bool              fis_i_check_content();
ICheckContent*    copy_i_check_content();
ICheckContent*    create_i_check_content_prop();
ICheckContent*    create_i_check_content_cnstrs();
ICheckContent*    new_i_check_content();
void              delete_i_check_content();

/*  i_check  */
Bool              fis_i_check();
Bool              fis_consis();
Bool              fis_inconsis();
void              decompose_i_check();
ICheck*           create_i_check();
Consis*           create_consis();
InConsis*         create_inconsis();
ICheck*           copy_i_check();
ICheck*           set_i_check();
ICheck*           new_i_check();
Consis*           new_consis();
InConsis*         new_inconsis();
void              delete_i_check();

/*  prop  */
Bool              fis_prop();
void              decompose_prop();
MId*              read_m_id_inProp();
ATerm*            read_a_term_inProp();
Prop*             create_prop();
Prop*             copy_prop();
Prop*             set_prop();
Prop*             write_m_id_inProp();
Prop*             write_a_term_inProp();
Prop*             new_prop();
void              delete_prop();

/*  a_term  */
Bool              fis_a_term();
void              decompose_a_term();
OTerm*            read_o_term_inATerm();
ObjList*          read_attrs_inATerm();
ObjList*          read_cnstrs_inATerm();
ATerm*            create_a_term();
ATerm*            copy_a_term();
ATerm*            set_a_term();
ATerm*            write_o_term_inATerm();
ATerm*            write_attrs_inATerm();
ATerm*            write_cnstrs_inATerm();
ATerm*            new_a_term();
ATerm*            insert_attrs_inATerm();
ATerm*            insert_cnstrs_inATerm();
ATerm*            add_attrs_inATerm();
ATerm*            add_cnstrs_inATerm();
Attr*             car_of_attrs_inATerm();
Cnstr*            car_of_cnstrs_inATerm();
void              delete_a_term();

/*  o_term  */
Bool              fis_o_term();
OTerm*            create_o_term_prolog();
OTerm*            create_o_term_c_o_term();
OTerm*            create_o_term_var();
OTerm*            create_o_term_dot();
OTerm*            create_o_term_list();
OTerm*            create_o_term_non_struct();
OTerm*            copy_o_term();
OTerm*            new_o_term();
void              delete_o_term();

/*  c_o_term  */
Bool              fis_c_o_term();
void              decompose_c_o_term();
char*             read_head_inCOTerm();
ObjList*          read_attrs_inCOTerm();
ObjList*          read_cnstrs_inCOTerm();
COTerm*           create_c_o_term();
COTerm*           copy_c_o_term();
COTerm*           set_c_o_term();
COTerm*           write_head_inCOTerm();
COTerm*           write_attrs_inCOTerm();
COTerm*           write_cnstrs_inCOTerm();
COTerm*           new_c_o_term();
COTerm*           insert_attrs_inCOTerm();
COTerm*           insert_cnstrs_inCOTerm();
COTerm*           add_attrs_inCOTerm();
COTerm*           add_cnstrs_inCOTerm();
Attr*             car_of_attrs_inCOTerm();
Cnstr*            car_of_cnstrs_inCOTerm();
void              delete_c_o_term();

/*  dot  */
Bool              fis_dot();
void              decompose_dot();
OTerm*            read_o_term_inDot();
Label*            read_label_inDot();
Dot*              create_dot();
Dot*              copy_dot();
Dot*              set_dot();
Dot*              write_o_term_inDot();
Dot*              write_label_inDot();
Dot*              new_dot();
void              delete_dot();

/*  label  */
Bool              fis_label();
Bool              fis_ind_lab();
Bool              fis_set_lab();
Bool              fis_curl_ind();
Bool              fis_curl_set();
void              decompose_label();
Label*            create_label();
IndLab*           create_ind_lab();
SetLab*           create_set_lab();
CurlInd*          create_curl_ind();
CurlSet*          create_curl_set();
Label*            copy_label();
Label*            set_label();
Label*            new_label();
IndLab*              new_ind_lab();
SetLab*              new_set_lab();
CurlInd*          new_curl_ind();
CurlSet*          new_curl_set();
void              delete_label();

/*  list  */
Bool              fis_list();
List*             create_list_normal();
List*             create_list_sub_list();
List*             copy_list();
List*             new_list();
void              delete_list();

/*  sub_list  */
Bool              fis_sub_list();
void              decompose_sub_list();
ObjList*          read_o_terms_inSubList();
Remain*           read_remain_inSubList();
SubList*          create_sub_list();
SubList*          copy_sub_list();
SubList*          set_sub_list();
SubList*          write_o_terms_inSubList();
SubList*          write_remain_inSubList();
SubList*          new_sub_list();
SubList*          insert_o_terms_inSubList();
SubList*          add_o_terms_inSubList();
OTerm*            car_of_o_terms_inSubList();
void              delete_sub_list();

/*  remain  */
Bool              fis_remain();
Remain*           create_remain_list();
Remain*           create_remain_var();
Remain*           copy_remain();
Remain*           new_remain();
void              delete_remain();

/*  non_struct  */
Bool              fis_non_struct();
NonStruct*        create_non_struct_exp_name();
NonStruct*        create_non_struct_string();
NonStruct*        create_non_struct_integer();
NonStruct*        copy_non_struct();
NonStruct*        new_non_struct();
void              delete_non_struct();

/*  exp_name  */
Bool              fis_exp_name();
void              decompose_exp_name();
ExpName*          create_exp_name();
ExpName*          copy_exp_name();
ExpName*          set_exp_name();
ExpName*          new_exp_name();
void              delete_exp_name();

/*  integer  */
Bool              fis_integer();
void              decompose_integer();
Integer*          create_integer();
Integer*          copy_integer();
Integer*          set_integer();
Integer*          new_integer();
void              delete_integer();

/*  attr  */
Bool              fis_attr();
void              decompose_attr();
Label*            read_label_inAttr();
AttrOp            read_attr_op();
Value*            read_value();
Attr*             create_attr();
Attr*             copy_attr();
Attr*             set_attr();
Attr*             write_label_inAttr();
Attr*             write_attr_op();
Attr*             write_value();
Attr*             new_attr();
void              delete_attr();
/* typedef int Bool; */

/*
 VALUE (union)
*/

Bool fis_value(/* PseudoObject* */);
Value* create_value_set(/* Set* */);
Value* create_value_sort(/* Sort* */);
Value* create_value_o_term(/* OTerm* */);
Value* copy_value(/* Value* */);
Value* new_value();
void delete_value(/* Value* */);


/*
 SET (have ObjList)
*/

Bool fis_set(/* PseudoObject* */);
void decompose_set(/* Set*, ObjList** */);
ObjList* read_o_terms_inSet(/* Set* */);
Set* create_set(/* ObjList* */);
Set* copy_set(/* Set* */);
Set* set_set(/* Set*, ObjList* */);
Set* write_o_terms_inSet(/* Set*, ObjList* */);
Set* new_set();
void delete_set(/* Set* */);
Set* insert_o_terms_inSet(/* Set*, ObjList* */);
Set* add_o_terms_inSet(/* Set*, ObjList* */);
OTerm* car_of_o_terms_inSet(/* Set* */);


/*
 CNSTR (union)
*/

Bool fis_cnstr(/* PseudoObject* */);
Cnstr* create_cnstr_cnstr(/* CnstrData* */);
Cnstr* create_cnstr_query_cnstr(/* QueryCnstr* */);
Cnstr* copy_cnstr(/* Cnstr* */);
Cnstr* new_cnstr();
void delete_cnstr(/* Cnstr* */);


/*
 CNSTR_DATA
*/

Bool fis_cnstr_data(/* PseudoObject* */);
void decompose_cnstr_data(/* CnstrData*, MId**, Value**, CnRel*, 
				   MId**, Value** */);
MId* read_m_id1_inCnstrData(/* CnstrData* */);
Value* read_value1(/* CnstrData* */);        
CnRel read_rel_inCnstrData(/* CnstrData* */);
MId* read_m_id2_inCnstrData(/* CnstrData* */);
Value* read_value2(/* CnstrData* */);        
CnstrData* create_cnstr_data(/* MId*, Value*, CnRel, MId*, Value* */);
CnstrData* copy_cnstr_data(/* CnstrData* */);
CnstrData* set_cnstr_data(/* CnstrData*, MId*, Value*, CnRel, MId*, Value* */);
CnstrData* write_m_id1_inCnstrData(/* CnstrData*, MId* */);   
CnstrData* write_value1(/* CnstrData*, Value* */);   
CnstrData* write_rel_inCnstrData(/* CnstrData*, CnRel */);
CnstrData* write_m_id2_inCnstrData(/* CnstrData*, MId* */);   
CnstrData* write_value2(/* CnstrData*, Value* */);   
CnstrData* new_cnstr_data();
void delete_cnstr_data(/* CnstrData* */);


/*
 QUERY_CNSTR
*/
 
Bool fis_query_cnstr(/* PseudoObject* */);
void decompose_query_cnstr(/* QueryCnstr*, MId**, MId** */);
MId* read_m_id1_inQueryCnstr(/* QueryCnstr* */);
MId* read_m_id2_inQueryCnstr(/* QueryCnstr* */);
QueryCnstr* create_query_cnstr(/* MId*, MId* */);
QueryCnstr* copy_query_cnstr(/* QueryCnstr* */);
QueryCnstr* set_query_cnstr(/* QueryCnstr*, MId*, MId* */);
QueryCnstr* write_m_id1_inQueryCnstr(/* QueryCnstr*, MId* */);
QueryCnstr* write_m_id2_inQueryCnstr(/* QueryCnstr*, MId* */);
QueryCnstr* new_query_cnstr();
void delete_query_cnstr(/* QueryCnstr* */);


/*
 PROLOG (have ObjList)
*/

Bool fis_prolog(/* PseudoObject* */);
void decompose_prolog(/* Prolog*, char**, ObjList** */);
char* read_head_inProlog(/* Prolog* */);
ObjList* read_o_terms_inProlog(/* Prolog* */);
Prolog* create_prolog(/* char*, ObjList* */);
Prolog* copy_prolog(/* Prolog* */);
Prolog* set_prolog(/* Prolog*, char*, ObjList* */);
Prolog* write_head_inProlog(/* Prolog*, char* */);
Prolog* write_o_terms_inProlog(/* Prolog*, ObjList* */);
Prolog* new_prolog();
void delete_prolog(/* Prolog* */);
Prolog* insert_o_terms_inProlog(/* Prolog*, ObjList* */);
Prolog* add_o_terms_inProlog(/* Prolog*, ObjList* */);
OTerm* car_of_o_terms_inProlog(/* Prolog */);


/*
 VAR
*/

Bool fis_var(/* PseudoObject* */);
void decompose_var(/* Var*, VarType*, char** */);
VarType read_type(/* Var* */);
char* read_var_data(/* Var* */);
Var* create_var(/* VarType, char* */);
Var* copy_var(/* Var* */);
Var* set_var(/* Var*, VarType, char* */);
Var* write_type(/* Var*, VarType */);
Var* write_var_data(/* Var*, char* */);
Var* new_var();
void delete_var(/* Var* */);


/*
 SORT
*/

Bool fis_sort(/* PseudoObject* */);
void decompose_sort(/* Sort*, Prolog** */);
Prolog* read_prolog(/* Sort* */);
Sort* create_sort(/* Prolog* */);
Sort* copy_sort(/* Sort* */);
Sort* set_sort(/* Sort*, Prolog* */);
Sort* write_prolog(/* Sort*, Prolog* */);
Sort* new_sort();
void delete_sort(/* Sort* */);


/*
 QUERY (have ObjList)
*/
 
Bool fis_query(/* PseudoObject* */);
void decompose_query(/* Query*, RuleClass*, ATerm** ObjList**, ObjList**,
			ObjList**, Program** */);
RuleClass read_query_class(/* Query* */);
ATerm* read_q_head(/* Query */);
ObjList* read_clusters_inQuery(/* Query* */);
ObjList* read_cnstrs_inQuery(/* Query* */);
ObjList* read_q_modes(/* Query* */);
Program* read_program_inQuery(/* Query* */);
Query* create_query(/* RuleClass, ATerm*, ObjList*, ObjList*, ObjList*, 
		       Program* */);
Query* copy_query(/* Query* */);
Query* set_query(/* Query*, RuleClass, ATerm*, ObjList*, ObjList*,
			ObjList*, Program* */);
Query* write_query_class(/* Query*, RuleClass */);
Query* write_q_head(/* Query*, ATerm* */);
Query* write_clusters_inQuery(/* Query*, ObjList* */);
Query* write_cnstrs_inQuery(/* Query*, ObjList* */);
Query* write_q_modes(/* Query*, ObjList* */);
Query* write_program_inQuery(/* Query*, Program* */);
Query* new_query();
void delete_query(/* Query* */);
Query* insert_clusters(/* Query*, ObjList* */);
Query* insert_cnstrs(/* Query*, ObjList* */);
Query* insert_q_modes(/* Query*, ObjList* */);
Query* add_clusters(/* Query*, ObjList* */);
Query* add_cnstrs(/* Query*, ObjList* */);
Query* add_q_modes(/* Query*, ObjList* */);
Cluster* car_of_clusters(/* Query* */);
Cnstr* car_of_cnstrs(/* Query* */);
QMode* car_of_q_modes(/* Query* */);


/*
 Q_MODE (union)
*/

Bool fis_q_mode(/* PseudoObject* */);
QMode* create_q_mode_p_mode(/* PMode* */);
QMode* create_q_mode_a_mode(/* AMode* */);
QMode* create_q_mode_i_mode(/* IMode* */);
QMode* create_q_mode_m_mode(/* MMode* */);
QMode* create_q_mode_e_mode(/* EMode* */);
QMode* copy_q_mode(/* QMode* */);
QMode* new_q_mode();
void delete_q_mode(/* QMode* */);


/*
 P_MODE
*/

Bool fis_p_mode(/* PseudoObject* */);
void decompose_p_mode(/* PMode*, PModeData* */); 
PModeData read_p_mode_data(/* PMode* */);
PMode* create_p_mode(/* PModeData */);
PMode* copy_p_mode(/* PMode* */);
PMode* set_p_mode(/* PMode*, PModeData */);
PMode* write_p_mode_data(/* PMode*, PModeData */);
PMode* new_p_mode();
void delete_p_mode(/* PMode* */);


/*
 A_MODE
*/

Bool fis_a_mode(/* PseudoObject* */);
void decompose_a_mode(/* AMode*, AModeData* */); 
AModeData read_a_mode_data(/* AMode* */);
AMode* create_a_mode(/* AModeData */);
AMode* copy_a_mode(/* AMode* */);
AMode* set_a_mode(/* AMode*, AModeData */);
AMode* write_a_mode_data(/* AMode*, AModeData */);
AMode* new_a_mode();
void delete_a_mode(/* AMode* */);


/*
 I_MODE
*/

Bool fis_i_mode(/* PseudoObject* */);
void decompose_i_mode(/* IMode*, IModeData* */); 
IModeData read_i_mode_data(/* IMode* */);
IMode* create_i_mode(/* IModeData */);
IMode* copy_i_mode(/* IMode* */);
IMode* set_i_mode(/* IMode*, IModeData */);
IMode* write_i_mode_data(/* IMode*, IModeData */);
IMode* new_i_mode();
void delete_i_mode(/* IMode* */);


/*
 M_MODE
*/

Bool fis_m_mode(/* PseudoObject* */);
void decompose_m_mode(/* MMode*, MModeData* */); 
MModeData read_m_mode_data(/* MMode* */);
MMode* create_m_mode(/* MModeData */);
MMode* copy_m_mode(/* MMode* */);
MMode* set_m_mode(/* MMode*, MModeData */);
MMode* write_m_mode_data(/* MMode*, MModeData */);
MMode* new_m_mode();
void delete_m_mode(/* MMode* */);


/*
 E_MODE
*/

Bool fis_e_mode(/* PseudoObject* */);
void decompose_e_mode(/* EMode*, EModeData* */); 
EModeData read_e_mode_data(/* EMode* */);
EMode* create_e_mode(/* EModeData* */);
EMode* copy_e_mode(/* EMode* */);
EMode* set_e_mode(/* EMode*, EModeData* */);
EMode* write_e_mode_data(/* EMode*, EModeData* */);
EMode* new_e_mode();
void delete_e_mode(/* EMode* */);


/*
 ANSWER (have ObjList)
*/

Bool fis_answer(/* PseudoObject* */);
void decompose_answer(/* Answer*, ObjList** */);
ObjList* read_answer_elements(/* Answer* */);
Answer* create_answer(/* ObjList* */);
Answer* copy_answer(/* Answer* */);
Answer* set_answer(/* Answer*, ObjList* */);
Answer* write_answer_elements(/* Answer*, ObjList* */);
Answer* new_answer();
void delete_answer(/* Answer* */);
Answer* insert_answer_elements(/* Answer*, ObjList* */);
Answer* add_answer_elements(/* Answer*, ObjList* */);
AnswerElement* car_of_answer_elements(/* Answer* */);


/*
 ANSWER_ELEMENT (have ObjList)
*/

Bool fis_answer_element(/* PseudoObject* */);
void decompose_answer_element(/* AnswerElement*, ObjList**, 
				 ObjList**, AnseExplanation** */);
ObjList* read_dot_cnstrs(/* AnswerElement* */);
ObjList* read_var_cnstrs(/* AnswerElement* */);
AnseExplanation* read_anse_explanation(/* AnswerElement* */);
AnswerElement* create_answer_element(/* ObjList*, ObjList*, 
					AnseExplanation* */);
AnswerElement* copy_answer_element(/* AnswerElement* */);
AnswerElement* set_answer_element(/* AnswerElement*, ObjList*, 
				     ObjList*, AnseExplanation* */);
AnswerElement* write_dot_cnstrs(/* AnswerElement*, ObjList* */);
AnswerElement* write_var_cnstrs(/* AnswerElement*, ObjList* */);
AnswerElement* write_anse_explanation
                        (/* AnswerElement*, AnseExplanation* */);
AnswerElement* new_answer_element();
void delete_answer_element(/* AnswerElement* */);
AnswerElement* insert_dot_cnstrs(/* AnswerElement*, ObjList* */);
AnswerElement* insert_var_cnstrs(/* AnswerElement*, ObjList* */);
AnswerElement* add_dot_cnstrs(/* AnswerElement*, ObjList* */);
AnswerElement* add_var_cnstrs(/* AnswerElement*, ObjList* */);
DotCnstr* car_of_dot_cnstrs(/* AnswerElement* */);
VarCnstr* car_of_var_cnstrs(/* AnswerElement* */);


/*
 ANSE_EXPLANATION (have ObjList)
*/

Bool fis_anse_explanation(/* PseudoObject* */);
void decompose_anse_explanation(/* AnseExplanation*, Explanation**,
				   ObjList** */);
Explanation* read_explanation_inAnseExplanation(/* AnseExplanation* */);
ObjList* read_rir_pairs(/* AnseExplanation* */);
AnseExplanation* create_anse_explanation(/* Explanation*, ObjList* */);
AnseExplanation* copy_anse_explanation(/* AnseExplanation* */);
AnseExplanation* set_anse_explanation(/* AnseExplanation*, Explanation*,
					 ObjList* */);
AnseExplanation* write_explanation_inAnseExplanation
                        (/* AnseExplanation*, Explanation* */);
AnseExplanation* write_rir_pairs(/* AnseExplanation*, ObjList* */);
AnseExplanation* new_anse_explanation();
void delete_anse_explanation(/* AnseExplanation* */);
AnseExplanation* insert_rir_pairs(/* AnseExplanation*, ObjList* */);
AnseExplanation* add_rir_pairs(/* AnseExplanation*, ObjList* */);
RirPair* car_of_rir_pairs(/* AnseExplanation* */);


/*
 RIR_PAIR
*/

Bool fis_rir_pair(/* PseudoObject* */);
void decompose_rir_pair(/* RirPair*, RuleId**, Rule** */);
RuleId* read_rule_id_inRirPair(/* RirPair* */);
Rule* read_rule(/* RirPair* */);
RirPair* create_rir_pair(/* RuleId*, Rule* */);
RirPair* copy_rir_pair(/* RirPair* */);
RirPair* set_rir_pair(/* RirPair*, RuleId*, Rule* */);
RirPair* write_rule_id_inRirPair(/* RirPair*, RuleId* */);
RirPair* write_rule(/* RirPair*, Rule* */);
RirPair* new_rir_pair();
void delete_rir_pair(/* RirPair* */);

/*
 DOT_CNSTR
*/

Bool fis_dot_cnstr(/* PseudoObject* */);
void decompose_dot_cnstr(/* DotCnstr*, MId**, Dot**, CnRel*, Value** */);
MId* read_m_id_inDotCnstr(/* DotCnstr* */);
Dot* read_dot_inDotCnstr(/* DotCnstr* */);
CnRel read_rel_inDotCnstr(/* DotCnstr* */);
Value* read_value_inDotCnstr(/* DotCnstr* */);
DotCnstr* create_dot_cnstr(/* MId, Dot*, CnRel, Value* */);
DotCnstr* copy_dot_cnstr(/* DotCnstr* */);
DotCnstr* set_dot_cnstr(/* DotCnstr*, MId*, Dot*, CnRel, Value* */);
DotCnstr* write_m_id_inDotCnstr(/* DotCnstr*, MId* */);
DotCnstr* write_dot_inDotCnstr(/* DotCnstr*, Dot* */);
DotCnstr* write_rel_inDotCnstr(/* DotCnstr*, CnRel */);
DotCnstr* write_value_inDotCnstr(/* DotCnstr*, Value* */);
DotCnstr* new_dot_cnstr();
void delete_dot_cnstr(/* DotCnstr* */);


/*
 VAR_CNSTR
*/

Bool fis_var_cnstr(/* PseudoObject* */);
void decompose_var_cnstr(/* VarCnstr*, Var**, CnRel*, Value** */);
Var* read_var_inVarCnstr(/* VarCnstr* */);
CnRel read_rel_inVarCnstr(/* VarCnstr* */);
Value* read_value_inVarCnstr(/* VarCnstr* */);
VarCnstr* create_var_cnstr(/* Var*, CnRel, Value* */);
VarCnstr* copy_var_cnstr(/* VarCnstr* */);
VarCnstr* set_var_cnstr(/* VarCnstr*, Var*, CnRel, Value* */);
VarCnstr* write_var_inVarCnstr(/* VarCnstr*, Var* */);
VarCnstr* write_rel_inVarCnstr(/* VarCnstr*, CnRel */);
VarCnstr* write_value_inVarCnstr(/* VarCnstr*, Value* */);
VarCnstr* new_var_cnstr();
void delete_var_cnstr(/* VarCnstr* */);


/* typedef int Bool; */

/*
 EXPLANATION (union)
*/

Bool fis_explanation(/* PseudoObject* */);
Explanation* create_explanation_unit(/* UnitExplanation* */);
Explanation* create_explanation_merge(/* MergeExplanation* */);
Explanation* create_explanation_lookup(/* LookupExplanation* */);
Explanation* copy_explanation(/* Explanation* */);
Explanation* new_explanation();
void delete_explanation(/* Explanation* */);


/*
 UNIT_EXPLANATION (union)
*/

Bool fis_unit_explanation(/* PseudoObject* */);
UnitExplanation* create_unit_explanation_one_rule(/* OneRule* */);
UnitExplanation* create_unit_explanation_inherit(/* Inherit* */);
UnitExplanation* copy_unit_explanation(/* UnitExplanation* */);
UnitExplanation* new_unit_explanation();
void delete_unit_explanation(/* UnitExplanation* */);


/*
 INHERIT (have ObjList)
*/

Bool fis_inherit(/* PseudoObject* */);
void decompose_inherit(/* Inherit*, OneRule**, ObjList**, ObjList** */);
OneRule* read_one_rule(/* Inherit* */);
ObjList* read_ups(/* Inherit* */);
ObjList* read_downs(/* Inherit* */);
Inherit* create_inherit(/* OneRule*, ObjList*, ObjList* */);
Inherit* copy_inherit(/* Inherit* */);
Inherit* set_inherit(/* Inherit*, OneRule*, ObjList*, ObjList* */);
Inherit* write_one_rule(/* Inherit*, OneRule* */);
Inherit* write_ups(/* Inherit*, ObjList* */);
Inherit* write_downs(/* Inherit*, ObjList* */);
Inherit* new_inherit();
void delete_inherit(/* Inherit* */);
Inherit* insert_ups(/* Inherit*, ObjList* */);
Inherit* insert_downs(/* Inherit*, ObjList* */);
Inherit* add_ups(/* Inherit*, ObjList* */);
Inherit* add_downs(/* Inherit*, ObjList* */);
OneRule* car_of_ups(/* Inherit* */);
OneRule* car_of_downs(/* Inherit* */);


/*
 MERGE_EXPLANATION (have ObjList)
*/

Bool fis_merge_explanation(/* PseudoObject* */);
void decompose_merge_explanation(/* MergeExplanation*, ObjList** */);
ObjList* read_unit_explanations(/* MergeExplanation* */);
MergeExplanation* create_merge_explanation(/* ObjList* */);
MergeExplanation* copy_merge_explanation(/* MergeExplanation* */);
MergeExplanation* set_merge_explanation(/* MergeExplanation*, ObjList* */);
MergeExplanation* write_unit_explanations(/* MergeExplanation*, ObjList* */);
MergeExplanation* new_merge_explanation();
void delete_merge_explanation(/* MergeExplanation* */);
MergeExplanation* insert_unit_explanations(/* MergeExplanation*, ObjList* */);
MergeExplanation* add_unit_explanations(/* MergeExplanation*, ObjList* */);
UnitExplanation* car_of_unit_explanations(/* MergeExplanation* */);


/*
 LOOKUP_EXPLANATION
*/

Bool fis_lookup_explanation(/* PseudoObject* */);
void decompose_lookup_explanation
         (/* LookupExplanation*, SubGoal**, int*, int*, Explanation** */);
SubGoal* read_sub_goal_inLookupExplanation(/* LookupExplanation* */);
int read_looked_s(/* LookupExplanation* */);
int read_looking_s(/* LookupExplanation* */);
Explanation* read_explanation_inLookupExplanation(/* LookupExplanation* */);
LookupExplanation* create_lookup_explanation
                            (/* SubGoal*, int, int, Explanation* */);
LookupExplanation* copy_lookup_explanation(/* LookupExplanation* */);
LookupExplanation* set_lookup_explanation
         (/* LookupExplanation*, SubGoal*, int, int, Explanation* */);
LookupExplanation* write_sub_goal_inLookupExplanation
                            (/* LookupExplanation*, SubGoal* */);
LookupExplanation* write_looked_s
                            (/* LookupExplanation*, int */);
LookupExplanation* write_looking_s
                            (/* LookupExplanation*, int */);
LookupExplanation* write_explanation_inLookupExplanation
                            (/* LookupExplanation*, Explanation* */);
LookupExplanation* new_lookup_explanation();
void delete_lookup_explanation(/* LookupExplanation* */);


/*
 ONE_RULE (union)
*/

Bool fis_one_rule(/* PseudoObject* */);
OneRule* create_one_rule_reduce(/* Reduce* */);
OneRule* create_one_rule_rule_id(/* Fact* */);
OneRule* create_one_rule_query(/* QueryExplanation* */);
OneRule* copy_one_rule(/* OneRule* */);
OneRule* new_one_rule();
void delete_one_rule(/* OneRule* */);


/*
 FACT
*/

Bool fis_fact(/* PseudoObject* */);
void decompose_fact(/* Fact*, char** */);
char* read_fact_data(/* Fact */);
Fact* create_fact(/* char* */);
Fact* copy_fact(/* Fact */);
Fact* set_fact(/* Fact*, char** */);
Fact* write_fact_data(/* Fact*, char** */);
Fact* new_fact();
void delete_fact(/* Fact */);

/*
 REDUCE (have ObjList)
*/

Bool fis_reduce(/* PseudoObject* */);
void decompose_reduce(/* Reduce*, SubGoal**, RuleId**, ObjList**, ObjList** */);
SubGoal* read_sub_goal_inReduce(/* Reduce* */);
RuleId* read_rule_id_inReduce(/* Reduce* */);
ObjList* read_explanations(/* Reduce* */);
ObjList* read_assumps(/* Reduce* */);
Reduce* create_reduce(/* SubGoal*, RuleId*, ObjList*, ObjList* */);
Reduce* copy_reduce(/* Reduce* */);
Reduce* set_reduce(/* Reduce*, SubGoal*, RuleId*, ObjList*, ObjList* */);
Reduce* write_sub_goal_inReduce(/* Reduce*, SubGoal* */);
Reduce* write_rule_id_inReduce(/* Reduce*, RuleId* */);
Reduce* write_explanations(/* Reduce*, ObjList* */);
Reduce* write_assumps(/* Reduce*, ObjList* */);
Reduce* new_reduce();
void delete_reduce(/* Reduce* */);
Reduce* insert_explanations(/* Reduce*, ObjList* */);
Reduce* insert_assumps(/* Reduce*, ObjList* */);
Reduce* add_explanations(/* Reduce*, ObjList* */);
Reduce* add_assumps(/* Reduce*, ObjList* */);
Explanation* car_of_explanations(/* Reduce* */);
Assump* car_of_assumps(/* Reduce* */);


/*
 SUB_GOAL (have ObjList)
*/

Bool fis_sub_goal(/* PseudoObject* */);
void decompose_sub_goal(/* SubGoal*, MId**, OTerm**, ObjList** */);
MId* read_m_id_inSubGoal(/* SubGoal* */);
OTerm* read_o_term_inSubGoal(/* SubGoal* */);
ObjList* read_vc_pairs_inSubGoal(/* SubGoal* */);
SubGoal* create_sub_goal(/* MId*, OTerm*, ObjList* */);
SubGoal* copy_sub_goal(/* SubGoal* */);
SubGoal* set_sub_goal(/* SubGoal*, MId*, OTerm*, ObjList* */);
SubGoal* write_m_id_inSubGoal(/* SubGoal*, MId* */);
SubGoal* write_o_term_inSubGoal(/* SubGoal*, OTerm* */);
SubGoal* write_vc_pairs_inSubGoal(/* SubGoal*, ObjList* */);
SubGoal* new_sub_goal();
void delete_sub_goal(/* SubGoal* */);
SubGoal* insert_vc_pairs_inSubGoal(/* SubGoal*, ObjList* */);
SubGoal* add_vc_pairs_inSubGoal(/* SubGoal*, ObjList* */);
VcPair* car_of_vc_pairs_inSubGoal(/* SubGoal* */);


/*
 VC_PAIR
*/

Bool fis_vc_pair(/* PseudoObject* */);
void decompose_vc_pair(/* VcPair*, Var**, Constraint** */);
Var* read_var_inVcPair(/* VcPair* */);
Constraint* read_constraint(/* VcPair* */);
VcPair* create_vc_pair(/* Var*, Constraint* */);
VcPair* copy_vc_pair(/* VcPair* */);
VcPair* set_vc_pair(/* VcPair*, Var*, Constraint* */);
VcPair* write_var_inVcPair(/* VcPair*, Var* */);
VcPair* write_constraint(/* VcPair*, Constraint* */);
VcPair* new_vc_pair();
void delete_vc_pair(/* VcPair* */);


/*
 CONSTRAINT
*/

Bool fis_constraint(/* PseudoObject* */);
void decompose_constraint(/* Constraint*, Con** */);
Con* read_const_data(/* Constraint* */);
Constraint* create_constraint(/* Con* */);
Constraint* copy_constraint(/* Constraint* */);
Constraint* set_constraint(/* Constraint*, Con* */);
Constraint* write_const_data(/* Constraint*, Con* */);
Constraint* new_constraint();
void delete_constraint(/* Constraint* */);


/*
 CON (have ObjList)
*/

Bool fis_con(/* PseudoObject* */);
void decompose_con(/* Con*, ObjList**, ObjList** */);
ObjList* read_o_terms1_inCon(/* Con* */);
ObjList* read_o_terms2_inCon(/* Con* */);
Con* create_con(/* ObjList*, ObjList* */);
Con* copy_con(/* Con* */);
Con* set_con(/* Con*, ObjList*, ObjList* */);
Con* write_o_terms1_inCon(/* Con*, ObjList* */);
Con* write_o_terms2_inCon(/* Con*, ObjList* */);
Con* new_con();
void delete_con(/* Con* */);
Con* insert_o_terms1_inCon(/* Con*, ObjList* */);
Con* insert_o_terms2_inCon(/* Con*, ObjList* */);
Con* add_o_terms1_inCon(/* Con*, ObjList* */);
Con* add_o_terms2_inCon(/* Con*, ObjList* */);
OTerm* car_of_o_terms1_inCon(/* Con* */);
OTerm* car_of_o_terms2_inCon(/* Con* */);


/*
 ASSUMP (have ObjList)
*/

Bool fis_assump(/* PseudoObject* */);
void decompose_assump(/* Assump*, MId**, Dot**, ObjList** */);
MId* read_m_id_inAssump(/* Assump* */);
Dot* read_dot_inAssump(/* Assump* */);
ObjList* read_vc_pairs_inAssump(/* Assump* */);
Assump* create_assump(/* MId*, Dot*, ObjList* */);
Assump* copy_assump(/* Assump* */);
Assump* set_assump(/* Assump*, MId*, Dot*, ObjList* */);
Assump* write_m_id_inAssump(/* Assump*, MId* */);
Assump* write_dot_inAssump(/* Assump*, Dot* */);
Assump* write_vc_pairs_inAssump(/* Assump*, ObjList* */);
Assump* new_assump();
void delete_assump(/* Assump* */);
Assump* insert_vc_pairs_inAssump(/* Assump*, ObjList* */);
Assump* add_vc_pairs_inAssump(/* Assump*, ObjList* */);
VcPair* car_of_vc_pairs_inAssump(/* Assump* */);


/*
 QUERY_EXPLANATION
*/

Bool fis_query_explanation(/* PseudoObject* */);
QueryExplanation* copy_query_explanation(/* QueryExplanation* */);
QueryExplanation* new_query_explanation();
void delete_query_explanation(/* QueryExplanation* */);



