4898794edd81be5285ea6e544acbedeaeb31bf78
max
  Tue Nov 23 08:10:57 2021 -0800
Fixing pointers to README file for license in all source code files. refs #27614

diff --git src/hg/near/hprdXmlToTab/hprd.c src/hg/near/hprdXmlToTab/hprd.c
index bf7f052..86a3e11 100644
--- src/hg/near/hprdXmlToTab/hprd.c
+++ src/hg/near/hprdXmlToTab/hprd.c
@@ -1,2175 +1,2175 @@
 /* hprd.c autoXml generated file */
 
 /* Copyright (C) 2009 The Regents of the University of California 
- * See README in this or parent directory for licensing information. */
+ * See kent/LICENSE or http://genome.ucsc.edu/license/ for licensing information. */
 
 #include "common.h"
 #include "xap.h"
 #include "hprd.h"
 
 
 void hprdEntrySetFree(struct hprdEntrySet **pObj)
 /* Free up hprdEntrySet. */
 {
 struct hprdEntrySet *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->level);
 freeMem(obj->version);
 freeMem(obj->xmlns);
 freeMem(obj->xmlnsxsi);
 freeMem(obj->xsischemaLocation);
 hprdEntryFree(&obj->hprdEntry);
 freez(pObj);
 }
 
 void hprdEntrySetFreeList(struct hprdEntrySet **pList)
 /* Free up list of hprdEntrySet. */
 {
 struct hprdEntrySet *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdEntrySetFree(&el);
     el = next;
     }
 }
 
 void hprdEntrySetSave(struct hprdEntrySet *obj, int indent, FILE *f)
 /* Save hprdEntrySet to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<entrySet");
 fprintf(f, " level=\"%s\"", obj->level);
 fprintf(f, " version=\"%s\"", obj->version);
 fprintf(f, " xmlns=\"%s\"", obj->xmlns);
 fprintf(f, " xmlnsxsi=\"%s\"", obj->xmlnsxsi);
 fprintf(f, " xsischemaLocation=\"%s\"", obj->xsischemaLocation);
 fprintf(f, ">");
 fprintf(f, "\n");
 hprdEntrySave(obj->hprdEntry, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</entrySet>\n");
 }
 
 struct hprdEntrySet *hprdEntrySetLoad(char *fileName)
 /* Load hprdEntrySet from XML file where it is root element. */
 {
 struct hprdEntrySet *obj;
 xapParseAny(fileName, "entrySet", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdEntrySet *hprdEntrySetLoadNext(struct xap *xap)
 /* Load next hprdEntrySet element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "entrySet");
 }
 
 void hprdEntryFree(struct hprdEntry **pObj)
 /* Free up hprdEntry. */
 {
 struct hprdEntry *obj = *pObj;
 if (obj == NULL) return;
 hprdSourceFree(&obj->hprdSource);
 hprdAvailabilityListFree(&obj->hprdAvailabilityList);
 hprdExperimentListFree(&obj->hprdExperimentList);
 hprdInteractorListFree(&obj->hprdInteractorList);
 hprdInteractionListFree(&obj->hprdInteractionList);
 freez(pObj);
 }
 
 void hprdEntryFreeList(struct hprdEntry **pList)
 /* Free up list of hprdEntry. */
 {
 struct hprdEntry *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdEntryFree(&el);
     el = next;
     }
 }
 
 void hprdEntrySave(struct hprdEntry *obj, int indent, FILE *f)
 /* Save hprdEntry to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<entry>");
 fprintf(f, "\n");
 hprdSourceSave(obj->hprdSource, indent+2, f);
 hprdAvailabilityListSave(obj->hprdAvailabilityList, indent+2, f);
 hprdExperimentListSave(obj->hprdExperimentList, indent+2, f);
 hprdInteractorListSave(obj->hprdInteractorList, indent+2, f);
 hprdInteractionListSave(obj->hprdInteractionList, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</entry>\n");
 }
 
 struct hprdEntry *hprdEntryLoad(char *fileName)
 /* Load hprdEntry from XML file where it is root element. */
 {
 struct hprdEntry *obj;
 xapParseAny(fileName, "entry", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdEntry *hprdEntryLoadNext(struct xap *xap)
 /* Load next hprdEntry element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "entry");
 }
 
 void hprdSourceFree(struct hprdSource **pObj)
 /* Free up hprdSource. */
 {
 struct hprdSource *obj = *pObj;
 if (obj == NULL) return;
 hprdNamesFree(&obj->hprdNames);
 hprdBibrefFree(&obj->hprdBibref);
 freez(pObj);
 }
 
 void hprdSourceFreeList(struct hprdSource **pList)
 /* Free up list of hprdSource. */
 {
 struct hprdSource *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdSourceFree(&el);
     el = next;
     }
 }
 
 void hprdSourceSave(struct hprdSource *obj, int indent, FILE *f)
 /* Save hprdSource to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<source>");
 fprintf(f, "\n");
 hprdNamesSave(obj->hprdNames, indent+2, f);
 hprdBibrefSave(obj->hprdBibref, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</source>\n");
 }
 
 struct hprdSource *hprdSourceLoad(char *fileName)
 /* Load hprdSource from XML file where it is root element. */
 {
 struct hprdSource *obj;
 xapParseAny(fileName, "source", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdSource *hprdSourceLoadNext(struct xap *xap)
 /* Load next hprdSource element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "source");
 }
 
 void hprdNamesFree(struct hprdNames **pObj)
 /* Free up hprdNames. */
 {
 struct hprdNames *obj = *pObj;
 if (obj == NULL) return;
 hprdShortLabelFree(&obj->hprdShortLabel);
 hprdFullNameFree(&obj->hprdFullName);
 hprdAliasFreeList(&obj->hprdAlias);
 freez(pObj);
 }
 
 void hprdNamesFreeList(struct hprdNames **pList)
 /* Free up list of hprdNames. */
 {
 struct hprdNames *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdNamesFree(&el);
     el = next;
     }
 }
 
 void hprdNamesSave(struct hprdNames *obj, int indent, FILE *f)
 /* Save hprdNames to file. */
 {
 struct hprdAlias *hprdAlias;
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<names>");
 fprintf(f, "\n");
 hprdShortLabelSave(obj->hprdShortLabel, indent+2, f);
 hprdFullNameSave(obj->hprdFullName, indent+2, f);
 for (hprdAlias = obj->hprdAlias; hprdAlias != NULL; hprdAlias = hprdAlias->next)
    {
    hprdAliasSave(hprdAlias, indent+2, f);
    }
 xapIndent(indent, f);
 fprintf(f, "</names>\n");
 }
 
 struct hprdNames *hprdNamesLoad(char *fileName)
 /* Load hprdNames from XML file where it is root element. */
 {
 struct hprdNames *obj;
 xapParseAny(fileName, "names", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdNames *hprdNamesLoadNext(struct xap *xap)
 /* Load next hprdNames element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "names");
 }
 
 void hprdShortLabelFree(struct hprdShortLabel **pObj)
 /* Free up hprdShortLabel. */
 {
 struct hprdShortLabel *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdShortLabelFreeList(struct hprdShortLabel **pList)
 /* Free up list of hprdShortLabel. */
 {
 struct hprdShortLabel *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdShortLabelFree(&el);
     el = next;
     }
 }
 
 void hprdShortLabelSave(struct hprdShortLabel *obj, int indent, FILE *f)
 /* Save hprdShortLabel to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<shortLabel>");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</shortLabel>\n");
 }
 
 struct hprdShortLabel *hprdShortLabelLoad(char *fileName)
 /* Load hprdShortLabel from XML file where it is root element. */
 {
 struct hprdShortLabel *obj;
 xapParseAny(fileName, "shortLabel", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdShortLabel *hprdShortLabelLoadNext(struct xap *xap)
 /* Load next hprdShortLabel element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "shortLabel");
 }
 
 void hprdFullNameFree(struct hprdFullName **pObj)
 /* Free up hprdFullName. */
 {
 struct hprdFullName *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdFullNameFreeList(struct hprdFullName **pList)
 /* Free up list of hprdFullName. */
 {
 struct hprdFullName *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdFullNameFree(&el);
     el = next;
     }
 }
 
 void hprdFullNameSave(struct hprdFullName *obj, int indent, FILE *f)
 /* Save hprdFullName to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<fullName>");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</fullName>\n");
 }
 
 struct hprdFullName *hprdFullNameLoad(char *fileName)
 /* Load hprdFullName from XML file where it is root element. */
 {
 struct hprdFullName *obj;
 xapParseAny(fileName, "fullName", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdFullName *hprdFullNameLoadNext(struct xap *xap)
 /* Load next hprdFullName element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "fullName");
 }
 
 void hprdAliasFree(struct hprdAlias **pObj)
 /* Free up hprdAlias. */
 {
 struct hprdAlias *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->type);
 freeMem(obj->typeAc);
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdAliasFreeList(struct hprdAlias **pList)
 /* Free up list of hprdAlias. */
 {
 struct hprdAlias *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdAliasFree(&el);
     el = next;
     }
 }
 
 void hprdAliasSave(struct hprdAlias *obj, int indent, FILE *f)
 /* Save hprdAlias to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<alias");
 fprintf(f, " type=\"%s\"", obj->type);
 fprintf(f, " typeAc=\"%s\"", obj->typeAc);
 fprintf(f, ">");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</alias>\n");
 }
 
 struct hprdAlias *hprdAliasLoad(char *fileName)
 /* Load hprdAlias from XML file where it is root element. */
 {
 struct hprdAlias *obj;
 xapParseAny(fileName, "alias", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdAlias *hprdAliasLoadNext(struct xap *xap)
 /* Load next hprdAlias element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "alias");
 }
 
 void hprdBibrefFree(struct hprdBibref **pObj)
 /* Free up hprdBibref. */
 {
 struct hprdBibref *obj = *pObj;
 if (obj == NULL) return;
 hprdXrefFree(&obj->hprdXref);
 freez(pObj);
 }
 
 void hprdBibrefFreeList(struct hprdBibref **pList)
 /* Free up list of hprdBibref. */
 {
 struct hprdBibref *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdBibrefFree(&el);
     el = next;
     }
 }
 
 void hprdBibrefSave(struct hprdBibref *obj, int indent, FILE *f)
 /* Save hprdBibref to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<bibref>");
 fprintf(f, "\n");
 hprdXrefSave(obj->hprdXref, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</bibref>\n");
 }
 
 struct hprdBibref *hprdBibrefLoad(char *fileName)
 /* Load hprdBibref from XML file where it is root element. */
 {
 struct hprdBibref *obj;
 xapParseAny(fileName, "bibref", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdBibref *hprdBibrefLoadNext(struct xap *xap)
 /* Load next hprdBibref element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "bibref");
 }
 
 void hprdXrefFree(struct hprdXref **pObj)
 /* Free up hprdXref. */
 {
 struct hprdXref *obj = *pObj;
 if (obj == NULL) return;
 hprdPrimaryRefFree(&obj->hprdPrimaryRef);
 hprdSecondaryRefFreeList(&obj->hprdSecondaryRef);
 freez(pObj);
 }
 
 void hprdXrefFreeList(struct hprdXref **pList)
 /* Free up list of hprdXref. */
 {
 struct hprdXref *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdXrefFree(&el);
     el = next;
     }
 }
 
 void hprdXrefSave(struct hprdXref *obj, int indent, FILE *f)
 /* Save hprdXref to file. */
 {
 struct hprdSecondaryRef *hprdSecondaryRef;
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<xref>");
 fprintf(f, "\n");
 hprdPrimaryRefSave(obj->hprdPrimaryRef, indent+2, f);
 for (hprdSecondaryRef = obj->hprdSecondaryRef; hprdSecondaryRef != NULL; hprdSecondaryRef = hprdSecondaryRef->next)
    {
    hprdSecondaryRefSave(hprdSecondaryRef, indent+2, f);
    }
 xapIndent(indent, f);
 fprintf(f, "</xref>\n");
 }
 
 struct hprdXref *hprdXrefLoad(char *fileName)
 /* Load hprdXref from XML file where it is root element. */
 {
 struct hprdXref *obj;
 xapParseAny(fileName, "xref", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdXref *hprdXrefLoadNext(struct xap *xap)
 /* Load next hprdXref element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "xref");
 }
 
 void hprdPrimaryRefFree(struct hprdPrimaryRef **pObj)
 /* Free up hprdPrimaryRef. */
 {
 struct hprdPrimaryRef *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->db);
 freeMem(obj->id);
 freeMem(obj->dbAc);
 freeMem(obj->refType);
 freeMem(obj->refTypeAc);
 freez(pObj);
 }
 
 void hprdPrimaryRefFreeList(struct hprdPrimaryRef **pList)
 /* Free up list of hprdPrimaryRef. */
 {
 struct hprdPrimaryRef *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdPrimaryRefFree(&el);
     el = next;
     }
 }
 
 void hprdPrimaryRefSave(struct hprdPrimaryRef *obj, int indent, FILE *f)
 /* Save hprdPrimaryRef to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<primaryRef");
 fprintf(f, " db=\"%s\"", obj->db);
 fprintf(f, " id=\"%s\"", obj->id);
 if (obj->dbAc != NULL)
     fprintf(f, " dbAc=\"%s\"", obj->dbAc);
 if (obj->refType != NULL)
     fprintf(f, " refType=\"%s\"", obj->refType);
 if (obj->refTypeAc != NULL)
     fprintf(f, " refTypeAc=\"%s\"", obj->refTypeAc);
 fprintf(f, "/>\n");
 }
 
 struct hprdPrimaryRef *hprdPrimaryRefLoad(char *fileName)
 /* Load hprdPrimaryRef from XML file where it is root element. */
 {
 struct hprdPrimaryRef *obj;
 xapParseAny(fileName, "primaryRef", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdPrimaryRef *hprdPrimaryRefLoadNext(struct xap *xap)
 /* Load next hprdPrimaryRef element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "primaryRef");
 }
 
 void hprdSecondaryRefFree(struct hprdSecondaryRef **pObj)
 /* Free up hprdSecondaryRef. */
 {
 struct hprdSecondaryRef *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->db);
 freeMem(obj->id);
 freeMem(obj->dbAc);
 freeMem(obj->refType);
 freeMem(obj->refTypeAc);
 freez(pObj);
 }
 
 void hprdSecondaryRefFreeList(struct hprdSecondaryRef **pList)
 /* Free up list of hprdSecondaryRef. */
 {
 struct hprdSecondaryRef *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdSecondaryRefFree(&el);
     el = next;
     }
 }
 
 void hprdSecondaryRefSave(struct hprdSecondaryRef *obj, int indent, FILE *f)
 /* Save hprdSecondaryRef to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<secondaryRef");
 fprintf(f, " db=\"%s\"", obj->db);
 fprintf(f, " id=\"%s\"", obj->id);
 if (obj->dbAc != NULL)
     fprintf(f, " dbAc=\"%s\"", obj->dbAc);
 if (obj->refType != NULL)
     fprintf(f, " refType=\"%s\"", obj->refType);
 if (obj->refTypeAc != NULL)
     fprintf(f, " refTypeAc=\"%s\"", obj->refTypeAc);
 fprintf(f, "/>\n");
 }
 
 struct hprdSecondaryRef *hprdSecondaryRefLoad(char *fileName)
 /* Load hprdSecondaryRef from XML file where it is root element. */
 {
 struct hprdSecondaryRef *obj;
 xapParseAny(fileName, "secondaryRef", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdSecondaryRef *hprdSecondaryRefLoadNext(struct xap *xap)
 /* Load next hprdSecondaryRef element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "secondaryRef");
 }
 
 void hprdAvailabilityListFree(struct hprdAvailabilityList **pObj)
 /* Free up hprdAvailabilityList. */
 {
 struct hprdAvailabilityList *obj = *pObj;
 if (obj == NULL) return;
 hprdAvailabilityFree(&obj->hprdAvailability);
 freez(pObj);
 }
 
 void hprdAvailabilityListFreeList(struct hprdAvailabilityList **pList)
 /* Free up list of hprdAvailabilityList. */
 {
 struct hprdAvailabilityList *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdAvailabilityListFree(&el);
     el = next;
     }
 }
 
 void hprdAvailabilityListSave(struct hprdAvailabilityList *obj, int indent, FILE *f)
 /* Save hprdAvailabilityList to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<availabilityList>");
 fprintf(f, "\n");
 hprdAvailabilitySave(obj->hprdAvailability, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</availabilityList>\n");
 }
 
 struct hprdAvailabilityList *hprdAvailabilityListLoad(char *fileName)
 /* Load hprdAvailabilityList from XML file where it is root element. */
 {
 struct hprdAvailabilityList *obj;
 xapParseAny(fileName, "availabilityList", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdAvailabilityList *hprdAvailabilityListLoadNext(struct xap *xap)
 /* Load next hprdAvailabilityList element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "availabilityList");
 }
 
 void hprdAvailabilityFree(struct hprdAvailability **pObj)
 /* Free up hprdAvailability. */
 {
 struct hprdAvailability *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->id);
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdAvailabilityFreeList(struct hprdAvailability **pList)
 /* Free up list of hprdAvailability. */
 {
 struct hprdAvailability *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdAvailabilityFree(&el);
     el = next;
     }
 }
 
 void hprdAvailabilitySave(struct hprdAvailability *obj, int indent, FILE *f)
 /* Save hprdAvailability to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<availability");
 fprintf(f, " id=\"%s\"", obj->id);
 fprintf(f, ">");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</availability>\n");
 }
 
 struct hprdAvailability *hprdAvailabilityLoad(char *fileName)
 /* Load hprdAvailability from XML file where it is root element. */
 {
 struct hprdAvailability *obj;
 xapParseAny(fileName, "availability", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdAvailability *hprdAvailabilityLoadNext(struct xap *xap)
 /* Load next hprdAvailability element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "availability");
 }
 
 void hprdExperimentListFree(struct hprdExperimentList **pObj)
 /* Free up hprdExperimentList. */
 {
 struct hprdExperimentList *obj = *pObj;
 if (obj == NULL) return;
 hprdExperimentDescriptionFreeList(&obj->hprdExperimentDescription);
 hprdExperimentRefFreeList(&obj->hprdExperimentRef);
 freez(pObj);
 }
 
 void hprdExperimentListFreeList(struct hprdExperimentList **pList)
 /* Free up list of hprdExperimentList. */
 {
 struct hprdExperimentList *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdExperimentListFree(&el);
     el = next;
     }
 }
 
 void hprdExperimentListSave(struct hprdExperimentList *obj, int indent, FILE *f)
 /* Save hprdExperimentList to file. */
 {
 struct hprdExperimentDescription *hprdExperimentDescription;
 struct hprdExperimentRef *hprdExperimentRef;
 boolean isNode = TRUE;
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<experimentList>");
 for (hprdExperimentDescription = obj->hprdExperimentDescription; hprdExperimentDescription != NULL; hprdExperimentDescription = hprdExperimentDescription->next)
    {
    if (isNode)
        {
        fprintf(f, "\n");
        isNode = FALSE;
        }
    hprdExperimentDescriptionSave(hprdExperimentDescription, indent+2, f);
    }
 for (hprdExperimentRef = obj->hprdExperimentRef; hprdExperimentRef != NULL; hprdExperimentRef = hprdExperimentRef->next)
    {
    if (isNode)
        {
        fprintf(f, "\n");
        isNode = FALSE;
        }
    hprdExperimentRefSave(hprdExperimentRef, indent+2, f);
    }
 if (!isNode)
     xapIndent(indent, f);
 fprintf(f, "</experimentList>\n");
 }
 
 struct hprdExperimentList *hprdExperimentListLoad(char *fileName)
 /* Load hprdExperimentList from XML file where it is root element. */
 {
 struct hprdExperimentList *obj;
 xapParseAny(fileName, "experimentList", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdExperimentList *hprdExperimentListLoadNext(struct xap *xap)
 /* Load next hprdExperimentList element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "experimentList");
 }
 
 void hprdExperimentDescriptionFree(struct hprdExperimentDescription **pObj)
 /* Free up hprdExperimentDescription. */
 {
 struct hprdExperimentDescription *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->id);
 hprdBibrefFree(&obj->hprdBibref);
 hprdInteractionDetectionMethodFree(&obj->hprdInteractionDetectionMethod);
 freez(pObj);
 }
 
 void hprdExperimentDescriptionFreeList(struct hprdExperimentDescription **pList)
 /* Free up list of hprdExperimentDescription. */
 {
 struct hprdExperimentDescription *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdExperimentDescriptionFree(&el);
     el = next;
     }
 }
 
 void hprdExperimentDescriptionSave(struct hprdExperimentDescription *obj, int indent, FILE *f)
 /* Save hprdExperimentDescription to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<experimentDescription");
 fprintf(f, " id=\"%s\"", obj->id);
 fprintf(f, ">");
 fprintf(f, "\n");
 hprdBibrefSave(obj->hprdBibref, indent+2, f);
 hprdInteractionDetectionMethodSave(obj->hprdInteractionDetectionMethod, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</experimentDescription>\n");
 }
 
 struct hprdExperimentDescription *hprdExperimentDescriptionLoad(char *fileName)
 /* Load hprdExperimentDescription from XML file where it is root element. */
 {
 struct hprdExperimentDescription *obj;
 xapParseAny(fileName, "experimentDescription", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdExperimentDescription *hprdExperimentDescriptionLoadNext(struct xap *xap)
 /* Load next hprdExperimentDescription element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "experimentDescription");
 }
 
 void hprdInteractionDetectionMethodFree(struct hprdInteractionDetectionMethod **pObj)
 /* Free up hprdInteractionDetectionMethod. */
 {
 struct hprdInteractionDetectionMethod *obj = *pObj;
 if (obj == NULL) return;
 hprdNamesFree(&obj->hprdNames);
 hprdXrefFree(&obj->hprdXref);
 freez(pObj);
 }
 
 void hprdInteractionDetectionMethodFreeList(struct hprdInteractionDetectionMethod **pList)
 /* Free up list of hprdInteractionDetectionMethod. */
 {
 struct hprdInteractionDetectionMethod *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractionDetectionMethodFree(&el);
     el = next;
     }
 }
 
 void hprdInteractionDetectionMethodSave(struct hprdInteractionDetectionMethod *obj, int indent, FILE *f)
 /* Save hprdInteractionDetectionMethod to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interactionDetectionMethod>");
 fprintf(f, "\n");
 hprdNamesSave(obj->hprdNames, indent+2, f);
 hprdXrefSave(obj->hprdXref, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</interactionDetectionMethod>\n");
 }
 
 struct hprdInteractionDetectionMethod *hprdInteractionDetectionMethodLoad(char *fileName)
 /* Load hprdInteractionDetectionMethod from XML file where it is root element. */
 {
 struct hprdInteractionDetectionMethod *obj;
 xapParseAny(fileName, "interactionDetectionMethod", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteractionDetectionMethod *hprdInteractionDetectionMethodLoadNext(struct xap *xap)
 /* Load next hprdInteractionDetectionMethod element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interactionDetectionMethod");
 }
 
 void hprdExperimentRefFree(struct hprdExperimentRef **pObj)
 /* Free up hprdExperimentRef. */
 {
 struct hprdExperimentRef *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdExperimentRefFreeList(struct hprdExperimentRef **pList)
 /* Free up list of hprdExperimentRef. */
 {
 struct hprdExperimentRef *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdExperimentRefFree(&el);
     el = next;
     }
 }
 
 void hprdExperimentRefSave(struct hprdExperimentRef *obj, int indent, FILE *f)
 /* Save hprdExperimentRef to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<experimentRef>");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</experimentRef>\n");
 }
 
 struct hprdExperimentRef *hprdExperimentRefLoad(char *fileName)
 /* Load hprdExperimentRef from XML file where it is root element. */
 {
 struct hprdExperimentRef *obj;
 xapParseAny(fileName, "experimentRef", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdExperimentRef *hprdExperimentRefLoadNext(struct xap *xap)
 /* Load next hprdExperimentRef element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "experimentRef");
 }
 
 void hprdInteractorListFree(struct hprdInteractorList **pObj)
 /* Free up hprdInteractorList. */
 {
 struct hprdInteractorList *obj = *pObj;
 if (obj == NULL) return;
 hprdInteractorFreeList(&obj->hprdInteractor);
 freez(pObj);
 }
 
 void hprdInteractorListFreeList(struct hprdInteractorList **pList)
 /* Free up list of hprdInteractorList. */
 {
 struct hprdInteractorList *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractorListFree(&el);
     el = next;
     }
 }
 
 void hprdInteractorListSave(struct hprdInteractorList *obj, int indent, FILE *f)
 /* Save hprdInteractorList to file. */
 {
 struct hprdInteractor *hprdInteractor;
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interactorList>");
 fprintf(f, "\n");
 for (hprdInteractor = obj->hprdInteractor; hprdInteractor != NULL; hprdInteractor = hprdInteractor->next)
    {
    hprdInteractorSave(hprdInteractor, indent+2, f);
    }
 xapIndent(indent, f);
 fprintf(f, "</interactorList>\n");
 }
 
 struct hprdInteractorList *hprdInteractorListLoad(char *fileName)
 /* Load hprdInteractorList from XML file where it is root element. */
 {
 struct hprdInteractorList *obj;
 xapParseAny(fileName, "interactorList", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteractorList *hprdInteractorListLoadNext(struct xap *xap)
 /* Load next hprdInteractorList element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interactorList");
 }
 
 void hprdInteractorFree(struct hprdInteractor **pObj)
 /* Free up hprdInteractor. */
 {
 struct hprdInteractor *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->id);
 hprdNamesFree(&obj->hprdNames);
 hprdXrefFree(&obj->hprdXref);
 hprdInteractorTypeFree(&obj->hprdInteractorType);
 hprdOrganismFree(&obj->hprdOrganism);
 hprdSequenceFree(&obj->hprdSequence);
 freez(pObj);
 }
 
 void hprdInteractorFreeList(struct hprdInteractor **pList)
 /* Free up list of hprdInteractor. */
 {
 struct hprdInteractor *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractorFree(&el);
     el = next;
     }
 }
 
 void hprdInteractorSave(struct hprdInteractor *obj, int indent, FILE *f)
 /* Save hprdInteractor to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interactor");
 fprintf(f, " id=\"%s\"", obj->id);
 fprintf(f, ">");
 fprintf(f, "\n");
 hprdNamesSave(obj->hprdNames, indent+2, f);
 hprdXrefSave(obj->hprdXref, indent+2, f);
 hprdInteractorTypeSave(obj->hprdInteractorType, indent+2, f);
 hprdOrganismSave(obj->hprdOrganism, indent+2, f);
 hprdSequenceSave(obj->hprdSequence, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</interactor>\n");
 }
 
 struct hprdInteractor *hprdInteractorLoad(char *fileName)
 /* Load hprdInteractor from XML file where it is root element. */
 {
 struct hprdInteractor *obj;
 xapParseAny(fileName, "interactor", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteractor *hprdInteractorLoadNext(struct xap *xap)
 /* Load next hprdInteractor element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interactor");
 }
 
 void hprdInteractorTypeFree(struct hprdInteractorType **pObj)
 /* Free up hprdInteractorType. */
 {
 struct hprdInteractorType *obj = *pObj;
 if (obj == NULL) return;
 hprdNamesFree(&obj->hprdNames);
 hprdXrefFree(&obj->hprdXref);
 freez(pObj);
 }
 
 void hprdInteractorTypeFreeList(struct hprdInteractorType **pList)
 /* Free up list of hprdInteractorType. */
 {
 struct hprdInteractorType *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractorTypeFree(&el);
     el = next;
     }
 }
 
 void hprdInteractorTypeSave(struct hprdInteractorType *obj, int indent, FILE *f)
 /* Save hprdInteractorType to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interactorType>");
 fprintf(f, "\n");
 hprdNamesSave(obj->hprdNames, indent+2, f);
 hprdXrefSave(obj->hprdXref, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</interactorType>\n");
 }
 
 struct hprdInteractorType *hprdInteractorTypeLoad(char *fileName)
 /* Load hprdInteractorType from XML file where it is root element. */
 {
 struct hprdInteractorType *obj;
 xapParseAny(fileName, "interactorType", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteractorType *hprdInteractorTypeLoadNext(struct xap *xap)
 /* Load next hprdInteractorType element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interactorType");
 }
 
 void hprdOrganismFree(struct hprdOrganism **pObj)
 /* Free up hprdOrganism. */
 {
 struct hprdOrganism *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->ncbiTaxId);
 hprdNamesFree(&obj->hprdNames);
 freez(pObj);
 }
 
 void hprdOrganismFreeList(struct hprdOrganism **pList)
 /* Free up list of hprdOrganism. */
 {
 struct hprdOrganism *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdOrganismFree(&el);
     el = next;
     }
 }
 
 void hprdOrganismSave(struct hprdOrganism *obj, int indent, FILE *f)
 /* Save hprdOrganism to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<organism");
 fprintf(f, " ncbiTaxId=\"%s\"", obj->ncbiTaxId);
 fprintf(f, ">");
 fprintf(f, "\n");
 hprdNamesSave(obj->hprdNames, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</organism>\n");
 }
 
 struct hprdOrganism *hprdOrganismLoad(char *fileName)
 /* Load hprdOrganism from XML file where it is root element. */
 {
 struct hprdOrganism *obj;
 xapParseAny(fileName, "organism", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdOrganism *hprdOrganismLoadNext(struct xap *xap)
 /* Load next hprdOrganism element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "organism");
 }
 
 void hprdSequenceFree(struct hprdSequence **pObj)
 /* Free up hprdSequence. */
 {
 struct hprdSequence *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdSequenceFreeList(struct hprdSequence **pList)
 /* Free up list of hprdSequence. */
 {
 struct hprdSequence *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdSequenceFree(&el);
     el = next;
     }
 }
 
 void hprdSequenceSave(struct hprdSequence *obj, int indent, FILE *f)
 /* Save hprdSequence to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<sequence>");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</sequence>\n");
 }
 
 struct hprdSequence *hprdSequenceLoad(char *fileName)
 /* Load hprdSequence from XML file where it is root element. */
 {
 struct hprdSequence *obj;
 xapParseAny(fileName, "sequence", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdSequence *hprdSequenceLoadNext(struct xap *xap)
 /* Load next hprdSequence element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "sequence");
 }
 
 void hprdInteractionListFree(struct hprdInteractionList **pObj)
 /* Free up hprdInteractionList. */
 {
 struct hprdInteractionList *obj = *pObj;
 if (obj == NULL) return;
 hprdInteractionFreeList(&obj->hprdInteraction);
 freez(pObj);
 }
 
 void hprdInteractionListFreeList(struct hprdInteractionList **pList)
 /* Free up list of hprdInteractionList. */
 {
 struct hprdInteractionList *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractionListFree(&el);
     el = next;
     }
 }
 
 void hprdInteractionListSave(struct hprdInteractionList *obj, int indent, FILE *f)
 /* Save hprdInteractionList to file. */
 {
 struct hprdInteraction *hprdInteraction;
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interactionList>");
 fprintf(f, "\n");
 for (hprdInteraction = obj->hprdInteraction; hprdInteraction != NULL; hprdInteraction = hprdInteraction->next)
    {
    hprdInteractionSave(hprdInteraction, indent+2, f);
    }
 xapIndent(indent, f);
 fprintf(f, "</interactionList>\n");
 }
 
 struct hprdInteractionList *hprdInteractionListLoad(char *fileName)
 /* Load hprdInteractionList from XML file where it is root element. */
 {
 struct hprdInteractionList *obj;
 xapParseAny(fileName, "interactionList", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteractionList *hprdInteractionListLoadNext(struct xap *xap)
 /* Load next hprdInteractionList element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interactionList");
 }
 
 void hprdInteractionFree(struct hprdInteraction **pObj)
 /* Free up hprdInteraction. */
 {
 struct hprdInteraction *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->id);
 hprdExperimentListFree(&obj->hprdExperimentList);
 hprdParticipantListFree(&obj->hprdParticipantList);
 freez(pObj);
 }
 
 void hprdInteractionFreeList(struct hprdInteraction **pList)
 /* Free up list of hprdInteraction. */
 {
 struct hprdInteraction *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractionFree(&el);
     el = next;
     }
 }
 
 void hprdInteractionSave(struct hprdInteraction *obj, int indent, FILE *f)
 /* Save hprdInteraction to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interaction");
 fprintf(f, " id=\"%s\"", obj->id);
 fprintf(f, ">");
 fprintf(f, "\n");
 hprdExperimentListSave(obj->hprdExperimentList, indent+2, f);
 hprdParticipantListSave(obj->hprdParticipantList, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</interaction>\n");
 }
 
 struct hprdInteraction *hprdInteractionLoad(char *fileName)
 /* Load hprdInteraction from XML file where it is root element. */
 {
 struct hprdInteraction *obj;
 xapParseAny(fileName, "interaction", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteraction *hprdInteractionLoadNext(struct xap *xap)
 /* Load next hprdInteraction element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interaction");
 }
 
 void hprdParticipantListFree(struct hprdParticipantList **pObj)
 /* Free up hprdParticipantList. */
 {
 struct hprdParticipantList *obj = *pObj;
 if (obj == NULL) return;
 hprdParticipantFreeList(&obj->hprdParticipant);
 freez(pObj);
 }
 
 void hprdParticipantListFreeList(struct hprdParticipantList **pList)
 /* Free up list of hprdParticipantList. */
 {
 struct hprdParticipantList *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdParticipantListFree(&el);
     el = next;
     }
 }
 
 void hprdParticipantListSave(struct hprdParticipantList *obj, int indent, FILE *f)
 /* Save hprdParticipantList to file. */
 {
 struct hprdParticipant *hprdParticipant;
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<participantList>");
 fprintf(f, "\n");
 for (hprdParticipant = obj->hprdParticipant; hprdParticipant != NULL; hprdParticipant = hprdParticipant->next)
    {
    hprdParticipantSave(hprdParticipant, indent+2, f);
    }
 xapIndent(indent, f);
 fprintf(f, "</participantList>\n");
 }
 
 struct hprdParticipantList *hprdParticipantListLoad(char *fileName)
 /* Load hprdParticipantList from XML file where it is root element. */
 {
 struct hprdParticipantList *obj;
 xapParseAny(fileName, "participantList", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdParticipantList *hprdParticipantListLoadNext(struct xap *xap)
 /* Load next hprdParticipantList element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "participantList");
 }
 
 void hprdParticipantFree(struct hprdParticipant **pObj)
 /* Free up hprdParticipant. */
 {
 struct hprdParticipant *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->id);
 hprdInteractorRefFree(&obj->hprdInteractorRef);
 freez(pObj);
 }
 
 void hprdParticipantFreeList(struct hprdParticipant **pList)
 /* Free up list of hprdParticipant. */
 {
 struct hprdParticipant *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdParticipantFree(&el);
     el = next;
     }
 }
 
 void hprdParticipantSave(struct hprdParticipant *obj, int indent, FILE *f)
 /* Save hprdParticipant to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<participant");
 fprintf(f, " id=\"%s\"", obj->id);
 fprintf(f, ">");
 fprintf(f, "\n");
 hprdInteractorRefSave(obj->hprdInteractorRef, indent+2, f);
 xapIndent(indent, f);
 fprintf(f, "</participant>\n");
 }
 
 struct hprdParticipant *hprdParticipantLoad(char *fileName)
 /* Load hprdParticipant from XML file where it is root element. */
 {
 struct hprdParticipant *obj;
 xapParseAny(fileName, "participant", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdParticipant *hprdParticipantLoadNext(struct xap *xap)
 /* Load next hprdParticipant element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "participant");
 }
 
 void hprdInteractorRefFree(struct hprdInteractorRef **pObj)
 /* Free up hprdInteractorRef. */
 {
 struct hprdInteractorRef *obj = *pObj;
 if (obj == NULL) return;
 freeMem(obj->text);
 freez(pObj);
 }
 
 void hprdInteractorRefFreeList(struct hprdInteractorRef **pList)
 /* Free up list of hprdInteractorRef. */
 {
 struct hprdInteractorRef *el, *next;
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     hprdInteractorRefFree(&el);
     el = next;
     }
 }
 
 void hprdInteractorRefSave(struct hprdInteractorRef *obj, int indent, FILE *f)
 /* Save hprdInteractorRef to file. */
 {
 if (obj == NULL) return;
 xapIndent(indent, f);
 fprintf(f, "<interactorRef>");
 fprintf(f, "%s", obj->text);
 fprintf(f, "</interactorRef>\n");
 }
 
 struct hprdInteractorRef *hprdInteractorRefLoad(char *fileName)
 /* Load hprdInteractorRef from XML file where it is root element. */
 {
 struct hprdInteractorRef *obj;
 xapParseAny(fileName, "interactorRef", hprdStartHandler, hprdEndHandler, NULL, &obj);
 return obj;
 }
 
 struct hprdInteractorRef *hprdInteractorRefLoadNext(struct xap *xap)
 /* Load next hprdInteractorRef element.  Use xapOpen to get xap. */
 {
 return xapNext(xap, "interactorRef");
 }
 
 void *hprdStartHandler(struct xap *xp, char *name, char **atts)
 /* Called by xap with start tag.  Does most of the parsing work. */
 {
 struct xapStack *st = xp->stack+1;
 int depth = xp->stackDepth;
 int i;
 
 if (sameString(name, "entrySet"))
     {
     struct hprdEntrySet *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "level"))
             obj->level = cloneString(val);
         else if (sameString(name, "version"))
             obj->version = cloneString(val);
         else if (sameString(name, "xmlns"))
             obj->xmlns = cloneString(val);
         else if (sameString(name, "xmlns:xsi"))
             obj->xmlnsxsi = cloneString(val);
         else if (sameString(name, "xsi:schemaLocation"))
             obj->xsischemaLocation = cloneString(val);
         }
     if (obj->level == NULL)
         xapError(xp, "missing level");
     if (obj->version == NULL)
         xapError(xp, "missing version");
     if (obj->xmlns == NULL)
         xapError(xp, "missing xmlns");
     if (obj->xmlnsxsi == NULL)
         xapError(xp, "missing xmlns:xsi");
     if (obj->xsischemaLocation == NULL)
         xapError(xp, "missing xsi:schemaLocation");
     return obj;
     }
 else if (sameString(name, "entry"))
     {
     struct hprdEntry *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "entrySet"))
             {
             struct hprdEntrySet *parent = st->object;
             slAddHead(&parent->hprdEntry, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "source"))
     {
     struct hprdSource *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "entry"))
             {
             struct hprdEntry *parent = st->object;
             slAddHead(&parent->hprdSource, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "names"))
     {
     struct hprdNames *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "source"))
             {
             struct hprdSource *parent = st->object;
             slAddHead(&parent->hprdNames, obj);
             }
         else if (sameString(st->elName, "interactionDetectionMethod"))
             {
             struct hprdInteractionDetectionMethod *parent = st->object;
             slAddHead(&parent->hprdNames, obj);
             }
         else if (sameString(st->elName, "interactor"))
             {
             struct hprdInteractor *parent = st->object;
             slAddHead(&parent->hprdNames, obj);
             }
         else if (sameString(st->elName, "interactorType"))
             {
             struct hprdInteractorType *parent = st->object;
             slAddHead(&parent->hprdNames, obj);
             }
         else if (sameString(st->elName, "organism"))
             {
             struct hprdOrganism *parent = st->object;
             slAddHead(&parent->hprdNames, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "shortLabel"))
     {
     struct hprdShortLabel *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "names"))
             {
             struct hprdNames *parent = st->object;
             slAddHead(&parent->hprdShortLabel, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "fullName"))
     {
     struct hprdFullName *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "names"))
             {
             struct hprdNames *parent = st->object;
             slAddHead(&parent->hprdFullName, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "alias"))
     {
     struct hprdAlias *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "type"))
             obj->type = cloneString(val);
         else if (sameString(name, "typeAc"))
             obj->typeAc = cloneString(val);
         }
     if (obj->type == NULL)
         xapError(xp, "missing type");
     if (obj->typeAc == NULL)
         xapError(xp, "missing typeAc");
     if (depth > 1)
         {
         if  (sameString(st->elName, "names"))
             {
             struct hprdNames *parent = st->object;
             slAddHead(&parent->hprdAlias, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "bibref"))
     {
     struct hprdBibref *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "source"))
             {
             struct hprdSource *parent = st->object;
             slAddHead(&parent->hprdBibref, obj);
             }
         else if (sameString(st->elName, "experimentDescription"))
             {
             struct hprdExperimentDescription *parent = st->object;
             slAddHead(&parent->hprdBibref, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "xref"))
     {
     struct hprdXref *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "bibref"))
             {
             struct hprdBibref *parent = st->object;
             slAddHead(&parent->hprdXref, obj);
             }
         else if (sameString(st->elName, "interactionDetectionMethod"))
             {
             struct hprdInteractionDetectionMethod *parent = st->object;
             slAddHead(&parent->hprdXref, obj);
             }
         else if (sameString(st->elName, "interactor"))
             {
             struct hprdInteractor *parent = st->object;
             slAddHead(&parent->hprdXref, obj);
             }
         else if (sameString(st->elName, "interactorType"))
             {
             struct hprdInteractorType *parent = st->object;
             slAddHead(&parent->hprdXref, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "primaryRef"))
     {
     struct hprdPrimaryRef *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "db"))
             obj->db = cloneString(val);
         else if (sameString(name, "id"))
             obj->id = cloneString(val);
         else if (sameString(name, "dbAc"))
             obj->dbAc = cloneString(val);
         else if (sameString(name, "refType"))
             obj->refType = cloneString(val);
         else if (sameString(name, "refTypeAc"))
             obj->refTypeAc = cloneString(val);
         }
     if (obj->db == NULL)
         xapError(xp, "missing db");
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "xref"))
             {
             struct hprdXref *parent = st->object;
             slAddHead(&parent->hprdPrimaryRef, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "secondaryRef"))
     {
     struct hprdSecondaryRef *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "db"))
             obj->db = cloneString(val);
         else if (sameString(name, "id"))
             obj->id = cloneString(val);
         else if (sameString(name, "dbAc"))
             obj->dbAc = cloneString(val);
         else if (sameString(name, "refType"))
             obj->refType = cloneString(val);
         else if (sameString(name, "refTypeAc"))
             obj->refTypeAc = cloneString(val);
         }
     if (obj->db == NULL)
         xapError(xp, "missing db");
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "xref"))
             {
             struct hprdXref *parent = st->object;
             slAddHead(&parent->hprdSecondaryRef, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "availabilityList"))
     {
     struct hprdAvailabilityList *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "entry"))
             {
             struct hprdEntry *parent = st->object;
             slAddHead(&parent->hprdAvailabilityList, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "availability"))
     {
     struct hprdAvailability *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "id"))
             obj->id = cloneString(val);
         }
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "availabilityList"))
             {
             struct hprdAvailabilityList *parent = st->object;
             slAddHead(&parent->hprdAvailability, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "experimentList"))
     {
     struct hprdExperimentList *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "entry"))
             {
             struct hprdEntry *parent = st->object;
             slAddHead(&parent->hprdExperimentList, obj);
             }
         else if (sameString(st->elName, "interaction"))
             {
             struct hprdInteraction *parent = st->object;
             slAddHead(&parent->hprdExperimentList, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "experimentDescription"))
     {
     struct hprdExperimentDescription *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "id"))
             obj->id = cloneString(val);
         }
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "experimentList"))
             {
             struct hprdExperimentList *parent = st->object;
             slAddHead(&parent->hprdExperimentDescription, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interactionDetectionMethod"))
     {
     struct hprdInteractionDetectionMethod *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "experimentDescription"))
             {
             struct hprdExperimentDescription *parent = st->object;
             slAddHead(&parent->hprdInteractionDetectionMethod, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "experimentRef"))
     {
     struct hprdExperimentRef *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "experimentList"))
             {
             struct hprdExperimentList *parent = st->object;
             slAddHead(&parent->hprdExperimentRef, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interactorList"))
     {
     struct hprdInteractorList *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "entry"))
             {
             struct hprdEntry *parent = st->object;
             slAddHead(&parent->hprdInteractorList, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interactor"))
     {
     struct hprdInteractor *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "id"))
             obj->id = cloneString(val);
         }
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "interactorList"))
             {
             struct hprdInteractorList *parent = st->object;
             slAddHead(&parent->hprdInteractor, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interactorType"))
     {
     struct hprdInteractorType *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "interactor"))
             {
             struct hprdInteractor *parent = st->object;
             slAddHead(&parent->hprdInteractorType, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "organism"))
     {
     struct hprdOrganism *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "ncbiTaxId"))
             obj->ncbiTaxId = cloneString(val);
         }
     if (obj->ncbiTaxId == NULL)
         xapError(xp, "missing ncbiTaxId");
     if (depth > 1)
         {
         if  (sameString(st->elName, "interactor"))
             {
             struct hprdInteractor *parent = st->object;
             slAddHead(&parent->hprdOrganism, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "sequence"))
     {
     struct hprdSequence *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "interactor"))
             {
             struct hprdInteractor *parent = st->object;
             slAddHead(&parent->hprdSequence, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interactionList"))
     {
     struct hprdInteractionList *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "entry"))
             {
             struct hprdEntry *parent = st->object;
             slAddHead(&parent->hprdInteractionList, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interaction"))
     {
     struct hprdInteraction *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "id"))
             obj->id = cloneString(val);
         }
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "interactionList"))
             {
             struct hprdInteractionList *parent = st->object;
             slAddHead(&parent->hprdInteraction, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "participantList"))
     {
     struct hprdParticipantList *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "interaction"))
             {
             struct hprdInteraction *parent = st->object;
             slAddHead(&parent->hprdParticipantList, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "participant"))
     {
     struct hprdParticipant *obj;
     AllocVar(obj);
     for (i=0; atts[i] != NULL; i += 2)
         {
         char *name = atts[i], *val = atts[i+1];
         if  (sameString(name, "id"))
             obj->id = cloneString(val);
         }
     if (obj->id == NULL)
         xapError(xp, "missing id");
     if (depth > 1)
         {
         if  (sameString(st->elName, "participantList"))
             {
             struct hprdParticipantList *parent = st->object;
             slAddHead(&parent->hprdParticipant, obj);
             }
         }
     return obj;
     }
 else if (sameString(name, "interactorRef"))
     {
     struct hprdInteractorRef *obj;
     AllocVar(obj);
     if (depth > 1)
         {
         if  (sameString(st->elName, "participant"))
             {
             struct hprdParticipant *parent = st->object;
             slAddHead(&parent->hprdInteractorRef, obj);
             }
         }
     return obj;
     }
 else
     {
     xapSkip(xp);
     return NULL;
     }
 }
 
 void hprdEndHandler(struct xap *xp, char *name)
 /* Called by xap with end tag.  Checks all required children are loaded. */
 {
 struct xapStack *stack = xp->stack;
 if (sameString(name, "entrySet"))
     {
     struct hprdEntrySet *obj = stack->object;
     if (obj->hprdEntry == NULL)
         xapError(xp, "Missing entry");
     if (obj->hprdEntry->next != NULL)
         xapError(xp, "Multiple entry");
     }
 else if (sameString(name, "entry"))
     {
     struct hprdEntry *obj = stack->object;
     if (obj->hprdSource == NULL)
         xapError(xp, "Missing source");
     if (obj->hprdSource->next != NULL)
         xapError(xp, "Multiple source");
     if (obj->hprdAvailabilityList == NULL)
         xapError(xp, "Missing availabilityList");
     if (obj->hprdAvailabilityList->next != NULL)
         xapError(xp, "Multiple availabilityList");
     if (obj->hprdExperimentList == NULL)
         xapError(xp, "Missing experimentList");
     if (obj->hprdExperimentList->next != NULL)
         xapError(xp, "Multiple experimentList");
     if (obj->hprdInteractorList == NULL)
         xapError(xp, "Missing interactorList");
     if (obj->hprdInteractorList->next != NULL)
         xapError(xp, "Multiple interactorList");
     if (obj->hprdInteractionList == NULL)
         xapError(xp, "Missing interactionList");
     if (obj->hprdInteractionList->next != NULL)
         xapError(xp, "Multiple interactionList");
     }
 else if (sameString(name, "source"))
     {
     struct hprdSource *obj = stack->object;
     if (obj->hprdNames == NULL)
         xapError(xp, "Missing names");
     if (obj->hprdNames->next != NULL)
         xapError(xp, "Multiple names");
     if (obj->hprdBibref == NULL)
         xapError(xp, "Missing bibref");
     if (obj->hprdBibref->next != NULL)
         xapError(xp, "Multiple bibref");
     }
 else if (sameString(name, "names"))
     {
     struct hprdNames *obj = stack->object;
     if (obj->hprdShortLabel == NULL)
         xapError(xp, "Missing shortLabel");
     if (obj->hprdShortLabel->next != NULL)
         xapError(xp, "Multiple shortLabel");
     if (obj->hprdFullName != NULL && obj->hprdFullName->next != NULL)
         xapError(xp, "Multiple fullName");
     slReverse(&obj->hprdAlias);
     }
 else if (sameString(name, "shortLabel"))
     {
     struct hprdShortLabel *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 else if (sameString(name, "fullName"))
     {
     struct hprdFullName *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 else if (sameString(name, "alias"))
     {
     struct hprdAlias *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 else if (sameString(name, "bibref"))
     {
     struct hprdBibref *obj = stack->object;
     if (obj->hprdXref == NULL)
         xapError(xp, "Missing xref");
     if (obj->hprdXref->next != NULL)
         xapError(xp, "Multiple xref");
     }
 else if (sameString(name, "xref"))
     {
     struct hprdXref *obj = stack->object;
     if (obj->hprdPrimaryRef == NULL)
         xapError(xp, "Missing primaryRef");
     if (obj->hprdPrimaryRef->next != NULL)
         xapError(xp, "Multiple primaryRef");
     slReverse(&obj->hprdSecondaryRef);
     }
 else if (sameString(name, "availabilityList"))
     {
     struct hprdAvailabilityList *obj = stack->object;
     if (obj->hprdAvailability == NULL)
         xapError(xp, "Missing availability");
     if (obj->hprdAvailability->next != NULL)
         xapError(xp, "Multiple availability");
     }
 else if (sameString(name, "availability"))
     {
     struct hprdAvailability *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 else if (sameString(name, "experimentList"))
     {
     struct hprdExperimentList *obj = stack->object;
     slReverse(&obj->hprdExperimentDescription);
     slReverse(&obj->hprdExperimentRef);
     }
 else if (sameString(name, "experimentDescription"))
     {
     struct hprdExperimentDescription *obj = stack->object;
     if (obj->hprdBibref == NULL)
         xapError(xp, "Missing bibref");
     if (obj->hprdBibref->next != NULL)
         xapError(xp, "Multiple bibref");
     if (obj->hprdInteractionDetectionMethod == NULL)
         xapError(xp, "Missing interactionDetectionMethod");
     if (obj->hprdInteractionDetectionMethod->next != NULL)
         xapError(xp, "Multiple interactionDetectionMethod");
     }
 else if (sameString(name, "interactionDetectionMethod"))
     {
     struct hprdInteractionDetectionMethod *obj = stack->object;
     if (obj->hprdNames == NULL)
         xapError(xp, "Missing names");
     if (obj->hprdNames->next != NULL)
         xapError(xp, "Multiple names");
     if (obj->hprdXref == NULL)
         xapError(xp, "Missing xref");
     if (obj->hprdXref->next != NULL)
         xapError(xp, "Multiple xref");
     }
 else if (sameString(name, "experimentRef"))
     {
     struct hprdExperimentRef *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 else if (sameString(name, "interactorList"))
     {
     struct hprdInteractorList *obj = stack->object;
     if (obj->hprdInteractor == NULL)
         xapError(xp, "Missing interactor");
     slReverse(&obj->hprdInteractor);
     }
 else if (sameString(name, "interactor"))
     {
     struct hprdInteractor *obj = stack->object;
     if (obj->hprdNames == NULL)
         xapError(xp, "Missing names");
     if (obj->hprdNames->next != NULL)
         xapError(xp, "Multiple names");
     if (obj->hprdXref == NULL)
         xapError(xp, "Missing xref");
     if (obj->hprdXref->next != NULL)
         xapError(xp, "Multiple xref");
     if (obj->hprdInteractorType == NULL)
         xapError(xp, "Missing interactorType");
     if (obj->hprdInteractorType->next != NULL)
         xapError(xp, "Multiple interactorType");
     if (obj->hprdOrganism == NULL)
         xapError(xp, "Missing organism");
     if (obj->hprdOrganism->next != NULL)
         xapError(xp, "Multiple organism");
     if (obj->hprdSequence == NULL)
         xapError(xp, "Missing sequence");
     if (obj->hprdSequence->next != NULL)
         xapError(xp, "Multiple sequence");
     }
 else if (sameString(name, "interactorType"))
     {
     struct hprdInteractorType *obj = stack->object;
     if (obj->hprdNames == NULL)
         xapError(xp, "Missing names");
     if (obj->hprdNames->next != NULL)
         xapError(xp, "Multiple names");
     if (obj->hprdXref == NULL)
         xapError(xp, "Missing xref");
     if (obj->hprdXref->next != NULL)
         xapError(xp, "Multiple xref");
     }
 else if (sameString(name, "organism"))
     {
     struct hprdOrganism *obj = stack->object;
     if (obj->hprdNames == NULL)
         xapError(xp, "Missing names");
     if (obj->hprdNames->next != NULL)
         xapError(xp, "Multiple names");
     }
 else if (sameString(name, "sequence"))
     {
     struct hprdSequence *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 else if (sameString(name, "interactionList"))
     {
     struct hprdInteractionList *obj = stack->object;
     if (obj->hprdInteraction == NULL)
         xapError(xp, "Missing interaction");
     slReverse(&obj->hprdInteraction);
     }
 else if (sameString(name, "interaction"))
     {
     struct hprdInteraction *obj = stack->object;
     if (obj->hprdExperimentList == NULL)
         xapError(xp, "Missing experimentList");
     if (obj->hprdExperimentList->next != NULL)
         xapError(xp, "Multiple experimentList");
     if (obj->hprdParticipantList == NULL)
         xapError(xp, "Missing participantList");
     if (obj->hprdParticipantList->next != NULL)
         xapError(xp, "Multiple participantList");
     }
 else if (sameString(name, "participantList"))
     {
     struct hprdParticipantList *obj = stack->object;
     if (obj->hprdParticipant == NULL)
         xapError(xp, "Missing participant");
     slReverse(&obj->hprdParticipant);
     }
 else if (sameString(name, "participant"))
     {
     struct hprdParticipant *obj = stack->object;
     if (obj->hprdInteractorRef == NULL)
         xapError(xp, "Missing interactorRef");
     if (obj->hprdInteractorRef->next != NULL)
         xapError(xp, "Multiple interactorRef");
     }
 else if (sameString(name, "interactorRef"))
     {
     struct hprdInteractorRef *obj = stack->object;
     obj->text = cloneString(stack->text->string);
     }
 }