ASN.1 dissectors regenerated with new asn2wrs to get updated field blurb

svn path=/trunk/; revision=18921

1 files changed, 313 insertions, 313 deletions

diff --git a/epan/dissectors/packet-dap.c b/epan/dissectors/packet-dap.c
index f07433d744..a67ce83704 100644
--- a/epan/dissectors/packet-dap.c
+++ b/epan/dissectors/packet-dap.c
@@ -5571,1255 +5571,1255 @@ void proto_register_dap(void) {
     { &hf_dap_securityParameters,
       { "securityParameters", "dap.securityParameters",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.SecurityParameters", HFILL }},
     { &hf_dap_performer,
       { "performer", "dap.performer",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_aliasDereferenced,
       { "aliasDereferenced", "dap.aliasDereferenced",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_notification,
       { "notification", "dap.notification",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "dap.SEQUENCE_OF_Attribute", HFILL }},
     { &hf_dap_notification_item,
       { "Item", "dap.notification_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_options,
       { "options", "dap.options",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ServiceControls/options", HFILL }},
+        "dap.ServiceControlOptions", HFILL }},
     { &hf_dap_priority,
       { "priority", "dap.priority",
         FT_INT32, BASE_DEC, VALS(dap_T_priority_vals), 0,
-        "ServiceControls/priority", HFILL }},
+        "dap.T_priority", HFILL }},
     { &hf_dap_timeLimit,
       { "timeLimit", "dap.timeLimit",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/timeLimit", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_sizeLimit,
       { "sizeLimit", "dap.sizeLimit",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/sizeLimit", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_scopeOfReferral,
       { "scopeOfReferral", "dap.scopeOfReferral",
         FT_INT32, BASE_DEC, VALS(dap_T_scopeOfReferral_vals), 0,
-        "ServiceControls/scopeOfReferral", HFILL }},
+        "dap.T_scopeOfReferral", HFILL }},
     { &hf_dap_attributeSizeLimit,
       { "attributeSizeLimit", "dap.attributeSizeLimit",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/attributeSizeLimit", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_manageDSAITPlaneRef,
       { "manageDSAITPlaneRef", "dap.manageDSAITPlaneRef",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceControls/manageDSAITPlaneRef", HFILL }},
+        "dap.T_manageDSAITPlaneRef", HFILL }},
     { &hf_dap_dsaName,
       { "dsaName", "dap.dsaName",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "ServiceControls/manageDSAITPlaneRef/dsaName", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_agreementID,
       { "agreementID", "dap.agreementID",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceControls/manageDSAITPlaneRef/agreementID", HFILL }},
+        "disp.AgreementID", HFILL }},
     { &hf_dap_serviceType,
       { "serviceType", "dap.serviceType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ServiceControls/serviceType", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_userClass,
       { "userClass", "dap.userClass",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/userClass", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_attributes,
       { "attributes", "dap.attributes",
         FT_UINT32, BASE_DEC, VALS(dap_T_attributes_vals), 0,
-        "EntryInformationSelection/attributes", HFILL }},
+        "dap.T_attributes", HFILL }},
     { &hf_dap_allUserAttributes,
       { "allUserAttributes", "dap.allUserAttributes",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryInformationSelection/attributes/allUserAttributes", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_select,
       { "select", "dap.select",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "dap.SET_OF_AttributeType", HFILL }},
     { &hf_dap_select_item,
       { "Item", "dap.select_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_infoTypes,
       { "infoTypes", "dap.infoTypes",
         FT_INT32, BASE_DEC, VALS(dap_T_infoTypes_vals), 0,
-        "EntryInformationSelection/infoTypes", HFILL }},
+        "dap.T_infoTypes", HFILL }},
     { &hf_dap_extraAttributes,
       { "extraAttributes", "dap.extraAttributes",
         FT_UINT32, BASE_DEC, VALS(dap_T_extraAttributes_vals), 0,
-        "EntryInformationSelection/extraAttributes", HFILL }},
+        "dap.T_extraAttributes", HFILL }},
     { &hf_dap_allOperationalAttributes,
       { "allOperationalAttributes", "dap.allOperationalAttributes",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryInformationSelection/extraAttributes/allOperationalAttributes", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_contextSelection,
       { "contextSelection", "dap.contextSelection",
         FT_UINT32, BASE_DEC, VALS(dap_ContextSelection_vals), 0,
-        "EntryInformationSelection/contextSelection", HFILL }},
+        "dap.ContextSelection", HFILL }},
     { &hf_dap_returnContexts,
       { "returnContexts", "dap.returnContexts",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformationSelection/returnContexts", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_familyReturn,
       { "familyReturn", "dap.familyReturn",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryInformationSelection/familyReturn", HFILL }},
+        "dap.FamilyReturn", HFILL }},
     { &hf_dap_allContexts,
       { "allContexts", "dap.allContexts",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContextSelection/allContexts", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_selectedContexts,
       { "selectedContexts", "dap.selectedContexts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ContextSelection/selectedContexts", HFILL }},
+        "dap.SET_OF_TypeAndContextAssertion", HFILL }},
     { &hf_dap_selectedContexts_item,
       { "Item", "dap.selectedContexts_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContextSelection/selectedContexts/_item", HFILL }},
+        "dap.TypeAndContextAssertion", HFILL }},
     { &hf_dap_type,
       { "type", "dap.type",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_contextAssertions,
       { "contextAssertions", "dap.contextAssertions",
         FT_UINT32, BASE_DEC, VALS(dap_T_contextAssertions_vals), 0,
-        "TypeAndContextAssertion/contextAssertions", HFILL }},
+        "dap.T_contextAssertions", HFILL }},
     { &hf_dap_preference,
       { "preference", "dap.preference",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/preference", HFILL }},
+        "dap.SEQUENCE_OF_ContextAssertion", HFILL }},
     { &hf_dap_preference_item,
       { "Item", "dap.preference_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/preference/_item", HFILL }},
+        "x509if.ContextAssertion", HFILL }},
     { &hf_dap_all,
       { "all", "dap.all",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/all", HFILL }},
+        "dap.SET_OF_ContextAssertion", HFILL }},
     { &hf_dap_all_item,
       { "Item", "dap.all_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/all/_item", HFILL }},
+        "x509if.ContextAssertion", HFILL }},
     { &hf_dap_memberSelect,
       { "memberSelect", "dap.memberSelect",
         FT_UINT32, BASE_DEC, VALS(dap_T_memberSelect_vals), 0,
-        "FamilyReturn/memberSelect", HFILL }},
+        "dap.T_memberSelect", HFILL }},
     { &hf_dap_familySelect,
       { "familySelect", "dap.familySelect",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyReturn/familySelect", HFILL }},
+        "dap.T_familySelect", HFILL }},
     { &hf_dap_familySelect_item,
       { "Item", "dap.familySelect_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "FamilyReturn/familySelect/_item", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_name,
       { "name", "dap.name",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_fromEntry,
       { "fromEntry", "dap.fromEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "EntryInformation/information", HFILL }},
+        "dap.T_entry_information", HFILL }},
     { &hf_dap_entry_information_item,
       { "Item", "dap.information_item",
         FT_UINT32, BASE_DEC, VALS(dap_EntryInformationItem_vals), 0,
-        "EntryInformation/information/_item", HFILL }},
+        "dap.EntryInformationItem", HFILL }},
     { &hf_dap_attributeType,
       { "attributeType", "dap.attributeType",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_attribute,
       { "attribute", "dap.attribute",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_incompleteEntry,
       { "incompleteEntry", "dap.incompleteEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformation/incompleteEntry", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_partialName,
       { "partialName", "dap.partialName",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformation/partialName", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_derivedEntry,
       { "derivedEntry", "dap.derivedEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformation/derivedEntry", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_family_class,
       { "family-class", "dap.family_class",
         FT_OID, BASE_NONE, NULL, 0,
-        "FamilyEntries/family-class", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_familyEntries,
       { "familyEntries", "dap.familyEntries",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyEntries/familyEntries", HFILL }},
+        "dap.SEQUENCE_OF_FamilyEntry", HFILL }},
     { &hf_dap_familyEntries_item,
       { "Item", "dap.familyEntries_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FamilyEntries/familyEntries/_item", HFILL }},
+        "dap.FamilyEntry", HFILL }},
     { &hf_dap_rdn,
       { "rdn", "dap.rdn",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.RelativeDistinguishedName", HFILL }},
     { &hf_dap_family_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyEntry/information", HFILL }},
+        "dap.FamilyInformation", HFILL }},
     { &hf_dap_family_information_item,
       { "Item", "dap.information_item",
         FT_UINT32, BASE_DEC, VALS(dap_T_family_information_item_vals), 0,
-        "FamilyEntry/information/_item", HFILL }},
+        "dap.T_family_information_item", HFILL }},
     { &hf_dap_family_info,
       { "family-info", "dap.family_info",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyEntry/family-info", HFILL }},
+        "dap.SEQUENCE_OF_FamilyEntries", HFILL }},
     { &hf_dap_family_info_item,
       { "Item", "dap.family_info_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FamilyEntry/family-info/_item", HFILL }},
+        "dap.FamilyEntries", HFILL }},
     { &hf_dap_filter_item,
       { "item", "dap.item",
         FT_UINT32, BASE_DEC, VALS(dap_FilterItem_vals), 0,
-        "Filter/item", HFILL }},
+        "dap.FilterItem", HFILL }},
     { &hf_dap_and,
       { "and", "dap.and",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Filter/and", HFILL }},
+        "dap.SetOfFilter", HFILL }},
     { &hf_dap_or,
       { "or", "dap.or",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Filter/or", HFILL }},
+        "dap.SetOfFilter", HFILL }},
     { &hf_dap_not,
       { "not", "dap.not",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "Filter/not", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_SetOfFilter_item,
       { "Item", "dap.SetOfFilter_item",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "SetOfFilter/_item", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_equality,
       { "equality", "dap.equality",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/equality", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_substrings,
       { "substrings", "dap.substrings",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings", HFILL }},
+        "dap.T_substrings", HFILL }},
     { &hf_dap_sunstringType,
       { "type", "dap.type",
         FT_OID, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/type", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_strings,
       { "strings", "dap.strings",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FilterItem/substrings/strings", HFILL }},
+        "dap.T_strings", HFILL }},
     { &hf_dap_strings_item,
       { "Item", "dap.strings_item",
         FT_UINT32, BASE_DEC, VALS(dap_T_strings_item_vals), 0,
-        "FilterItem/substrings/strings/_item", HFILL }},
+        "dap.T_strings_item", HFILL }},
     { &hf_dap_initial,
       { "initial", "dap.initial",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/initial", HFILL }},
+        "dap.T_initial", HFILL }},
     { &hf_dap_any,
       { "any", "dap.any",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/any", HFILL }},
+        "dap.T_any", HFILL }},
     { &hf_dap_final,
       { "final", "dap.final",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/final", HFILL }},
+        "dap.T_final", HFILL }},
     { &hf_dap_control,
       { "control", "dap.control",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/control", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_greaterOrEqual,
       { "greaterOrEqual", "dap.greaterOrEqual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/greaterOrEqual", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_lessOrEqual,
       { "lessOrEqual", "dap.lessOrEqual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/lessOrEqual", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_present,
       { "present", "dap.present",
         FT_OID, BASE_NONE, NULL, 0,
-        "FilterItem/present", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_approximateMatch,
       { "approximateMatch", "dap.approximateMatch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/approximateMatch", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_extensibleMatch,
       { "extensibleMatch", "dap.extensibleMatch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/extensibleMatch", HFILL }},
+        "dap.MatchingRuleAssertion", HFILL }},
     { &hf_dap_contextPresent,
       { "contextPresent", "dap.contextPresent",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/contextPresent", HFILL }},
+        "x509if.AttributeTypeAssertion", HFILL }},
     { &hf_dap_matchingRule,
       { "matchingRule", "dap.matchingRule",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MatchingRuleAssertion/matchingRule", HFILL }},
+        "dap.T_matchingRule", HFILL }},
     { &hf_dap_matchingRule_item,
       { "Item", "dap.matchingRule_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "MatchingRuleAssertion/matchingRule/_item", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_matchValue,
       { "matchValue", "dap.matchValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MatchingRuleAssertion/matchValue", HFILL }},
+        "dap.T_matchValue", HFILL }},
     { &hf_dap_dnAttributes,
       { "dnAttributes", "dap.dnAttributes",
         FT_BOOLEAN, 8, NULL, 0,
-        "MatchingRuleAssertion/dnAttributes", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_newRequest,
       { "newRequest", "dap.newRequest",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PagedResultsRequest/newRequest", HFILL }},
+        "dap.T_newRequest", HFILL }},
     { &hf_dap_pageSize,
       { "pageSize", "dap.pageSize",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PagedResultsRequest/newRequest/pageSize", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_sortKeys,
       { "sortKeys", "dap.sortKeys",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PagedResultsRequest/newRequest/sortKeys", HFILL }},
+        "dap.SEQUENCE_OF_SortKey", HFILL }},
     { &hf_dap_sortKeys_item,
       { "Item", "dap.sortKeys_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PagedResultsRequest/newRequest/sortKeys/_item", HFILL }},
+        "dap.SortKey", HFILL }},
     { &hf_dap_reverse,
       { "reverse", "dap.reverse",
         FT_BOOLEAN, 8, NULL, 0,
-        "PagedResultsRequest/newRequest/reverse", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_unmerged,
       { "unmerged", "dap.unmerged",
         FT_BOOLEAN, 8, NULL, 0,
-        "PagedResultsRequest/newRequest/unmerged", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_queryReference,
       { "queryReference", "dap.queryReference",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.OCTET_STRING", HFILL }},
     { &hf_dap_orderingRule,
       { "orderingRule", "dap.orderingRule",
         FT_OID, BASE_NONE, NULL, 0,
-        "SortKey/orderingRule", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_certification_path,
       { "certification-path", "dap.certification_path",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.CertificationPath", HFILL }},
     { &hf_dap_distinguished_name,
       { "name", "dap.name",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_time,
       { "time", "dap.time",
         FT_UINT32, BASE_DEC, VALS(x509af_Time_vals), 0,
-        "SecurityParameters/time", HFILL }},
+        "dap.Time", HFILL }},
     { &hf_dap_random,
       { "random", "dap.random",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SecurityParameters/random", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_target,
       { "target", "dap.target",
         FT_INT32, BASE_DEC, VALS(dap_ProtectionRequest_vals), 0,
-        "SecurityParameters/target", HFILL }},
+        "dap.ProtectionRequest", HFILL }},
     { &hf_dap_response,
       { "response", "dap.response",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SecurityParameters/response", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_operationCode,
       { "operationCode", "dap.operationCode",
         FT_UINT32, BASE_DEC, VALS(ros_Code_vals), 0,
-        "SecurityParameters/operationCode", HFILL }},
+        "ros.Code", HFILL }},
     { &hf_dap_attributeCertificationPath,
       { "attributeCertificationPath", "dap.attributeCertificationPath",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.AttributeCertificationPath", HFILL }},
     { &hf_dap_errorProtection,
       { "errorProtection", "dap.errorProtection",
         FT_INT32, BASE_DEC, VALS(dap_ErrorProtectionRequest_vals), 0,
-        "SecurityParameters/errorProtection", HFILL }},
+        "dap.ErrorProtectionRequest", HFILL }},
     { &hf_dap_errorCode,
       { "errorCode", "dap.errorCode",
         FT_UINT32, BASE_DEC, VALS(ros_Code_vals), 0,
-        "SecurityParameters/errorCode", HFILL }},
+        "ros.Code", HFILL }},
     { &hf_dap_utcTime,
       { "utcTime", "dap.utcTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/utcTime", HFILL }},
+        "dap.UTCTime", HFILL }},
     { &hf_dap_generalizedTime,
       { "generalizedTime", "dap.generalizedTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/generalizedTime", HFILL }},
+        "dap.GeneralizedTime", HFILL }},
     { &hf_dap_credentials,
       { "credentials", "dap.credentials",
         FT_UINT32, BASE_DEC, VALS(dap_Credentials_vals), 0,
-        "DirectoryBindArgument/credentials", HFILL }},
+        "dap.Credentials", HFILL }},
     { &hf_dap_versions,
       { "versions", "dap.versions",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.Versions", HFILL }},
     { &hf_dap_simple,
       { "simple", "dap.simple",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Credentials/simple", HFILL }},
+        "dap.SimpleCredentials", HFILL }},
     { &hf_dap_strong,
       { "strong", "dap.strong",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Credentials/strong", HFILL }},
+        "dap.StrongCredentials", HFILL }},
     { &hf_dap_externalProcedure,
       { "externalProcedure", "dap.externalProcedure",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Credentials/externalProcedure", HFILL }},
+        "acse.EXTERNAL", HFILL }},
     { &hf_dap_spkm,
       { "spkm", "dap.spkm",
         FT_UINT32, BASE_DEC, VALS(dap_SpkmCredentials_vals), 0,
-        "Credentials/spkm", HFILL }},
+        "dap.SpkmCredentials", HFILL }},
     { &hf_dap_validity,
       { "validity", "dap.validity",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SimpleCredentials/validity", HFILL }},
+        "dap.T_validity", HFILL }},
     { &hf_dap_time1,
       { "time1", "dap.time1",
         FT_UINT32, BASE_DEC, VALS(dap_T_time1_vals), 0,
-        "SimpleCredentials/validity/time1", HFILL }},
+        "dap.T_time1", HFILL }},
     { &hf_dap_utc,
       { "utc", "dap.utc",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.UTCTime", HFILL }},
     { &hf_dap_gt,
       { "gt", "dap.gt",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.GeneralizedTime", HFILL }},
     { &hf_dap_time2,
       { "time2", "dap.time2",
         FT_UINT32, BASE_DEC, VALS(dap_T_time2_vals), 0,
-        "SimpleCredentials/validity/time2", HFILL }},
+        "dap.T_time2", HFILL }},
     { &hf_dap_random1,
       { "random1", "dap.random1",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/validity/random1", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_random2,
       { "random2", "dap.random2",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/validity/random2", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_password,
       { "password", "dap.password",
         FT_UINT32, BASE_DEC, VALS(dap_T_password_vals), 0,
-        "SimpleCredentials/password", HFILL }},
+        "dap.T_password", HFILL }},
     { &hf_dap_unprotected,
       { "unprotected", "dap.unprotected",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/password/unprotected", HFILL }},
+        "dap.OCTET_STRING", HFILL }},
     { &hf_dap_protected,
       { "protected", "dap.protected",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SimpleCredentials/password/protected", HFILL }},
+        "dap.T_protected", HFILL }},
     { &hf_dap_protectedPassword,
       { "protectedPassword", "dap.protectedPassword",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/password/protected/protectedPassword", HFILL }},
+        "dap.OCTET_STRING", HFILL }},
     { &hf_dap_algorithmIdentifier,
       { "algorithmIdentifier", "dap.algorithmIdentifier",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.AlgorithmIdentifier", HFILL }},
     { &hf_dap_encrypted,
       { "encrypted", "dap.encrypted",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_bind_token,
       { "bind-token", "dap.bind_token",
         FT_NONE, BASE_NONE, NULL, 0,
-        "StrongCredentials/bind-token", HFILL }},
+        "dap.T_bind_token", HFILL }},
     { &hf_dap_req,
       { "req", "dap.req",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SpkmCredentials/req", HFILL }},
+        "dap.T_req", HFILL }},
     { &hf_dap_rep,
       { "rep", "dap.rep",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SpkmCredentials/rep", HFILL }},
+        "dap.T_rep", HFILL }},
     { &hf_dap_error,
       { "error", "dap.error",
         FT_UINT32, BASE_DEC, VALS(dap_T_error_vals), 0,
-        "DirectoryBindErrorData/error", HFILL }},
+        "dap.T_error", HFILL }},
     { &hf_dap_serviceProblem,
       { "serviceError", "dap.serviceError",
         FT_INT32, BASE_DEC, VALS(dap_ServiceProblem_vals), 0,
-        "DirectoryBindErrorData/error/serviceError", HFILL }},
+        "dap.ServiceProblem", HFILL }},
     { &hf_dap_securityProblem,
       { "securityError", "dap.securityError",
         FT_INT32, BASE_DEC, VALS(dap_SecurityProblem_vals), 0,
-        "DirectoryBindErrorData/error/securityError", HFILL }},
+        "dap.SecurityProblem", HFILL }},
     { &hf_dap_unsignedDirectoryBindError,
       { "unsignedDirectoryBindError", "dap.unsignedDirectoryBindError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DirectoryBindError/unsignedDirectoryBindError", HFILL }},
+        "dap.DirectoryBindErrorData", HFILL }},
     { &hf_dap_signedDirectoryBindError,
       { "signedDirectoryBindError", "dap.signedDirectoryBindError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DirectoryBindError/signedDirectoryBindError", HFILL }},
+        "dap.T_signedDirectoryBindError", HFILL }},
     { &hf_dap_directoryBindError,
       { "directoryBindError", "dap.directoryBindError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DirectoryBindError/signedDirectoryBindError/directoryBindError", HFILL }},
+        "dap.DirectoryBindErrorData", HFILL }},
     { &hf_dap_object,
       { "object", "dap.object",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_selection,
       { "selection", "dap.selection",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.EntryInformationSelection", HFILL }},
     { &hf_dap_modifyRightsRequest,
       { "modifyRightsRequest", "dap.modifyRightsRequest",
         FT_BOOLEAN, 8, NULL, 0,
-        "ReadArgumentData/modifyRightsRequest", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_serviceControls,
       { "serviceControls", "dap.serviceControls",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.ServiceControls", HFILL }},
     { &hf_dap_requestor,
       { "requestor", "dap.requestor",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_operationProgress,
       { "operationProgress", "dap.operationProgress",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dsp.OperationProgress", HFILL }},
     { &hf_dap_aliasedRDNs,
       { "aliasedRDNs", "dap.aliasedRDNs",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_criticalExtensions,
       { "criticalExtensions", "dap.criticalExtensions",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_referenceType,
       { "referenceType", "dap.referenceType",
         FT_UINT32, BASE_DEC, VALS(dsp_ReferenceType_vals), 0,
-        "", HFILL }},
+        "dsp.ReferenceType", HFILL }},
     { &hf_dap_entryOnly,
       { "entryOnly", "dap.entryOnly",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_nameResolveOnMaster,
       { "nameResolveOnMaster", "dap.nameResolveOnMaster",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_operationContexts,
       { "operationContexts", "dap.operationContexts",
         FT_UINT32, BASE_DEC, VALS(dap_ContextSelection_vals), 0,
-        "", HFILL }},
+        "dap.ContextSelection", HFILL }},
     { &hf_dap_familyGrouping,
       { "familyGrouping", "dap.familyGrouping",
         FT_UINT32, BASE_DEC, VALS(dap_FamilyGrouping_vals), 0,
-        "", HFILL }},
+        "dap.FamilyGrouping", HFILL }},
     { &hf_dap_rdnSequence,
       { "rdnSequence", "dap.rdnSequence",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Name/rdnSequence", HFILL }},
+        "x509if.RDNSequence", HFILL }},
     { &hf_dap_unsignedReadArgument,
       { "unsignedReadArgument", "dap.unsignedReadArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadArgument/unsignedReadArgument", HFILL }},
+        "dap.ReadArgumentData", HFILL }},
     { &hf_dap_signedReadArgument,
       { "signedReadArgument", "dap.signedReadArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadArgument/signedReadArgument", HFILL }},
+        "dap.T_signedReadArgument", HFILL }},
     { &hf_dap_readArgument,
       { "readArgument", "dap.readArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadArgument/signedReadArgument/readArgument", HFILL }},
+        "dap.ReadArgumentData", HFILL }},
     { &hf_dap_entry,
       { "entry", "dap.entry",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.EntryInformation", HFILL }},
     { &hf_dap_modifyRights,
       { "modifyRights", "dap.modifyRights",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ReadResultData/modifyRights", HFILL }},
+        "dap.ModifyRights", HFILL }},
     { &hf_dap_unsignedReadResult,
       { "unsignedReadResult", "dap.unsignedReadResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadResult/unsignedReadResult", HFILL }},
+        "dap.ReadResultData", HFILL }},
     { &hf_dap_signedReadResult,
       { "signedReadResult", "dap.signedReadResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadResult/signedReadResult", HFILL }},
+        "dap.T_signedReadResult", HFILL }},
     { &hf_dap_readResult,
       { "readResult", "dap.readResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadResult/signedReadResult/readResult", HFILL }},
+        "dap.ReadResultData", HFILL }},
     { &hf_dap_ModifyRights_item,
       { "Item", "dap.ModifyRights_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyRights/_item", HFILL }},
+        "dap.ModifyRights_item", HFILL }},
     { &hf_dap_item,
       { "item", "dap.item",
         FT_UINT32, BASE_DEC, VALS(dap_T_item_vals), 0,
-        "ModifyRights/_item/item", HFILL }},
+        "dap.T_item", HFILL }},
     { &hf_dap_item_entry,
       { "entry", "dap.entry",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyRights/_item/item/entry", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_attribute_type,
       { "attribute", "dap.attribute",
         FT_OID, BASE_NONE, NULL, 0,
-        "ModifyRights/_item/item/attribute", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_value_assertion,
       { "value", "dap.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyRights/_item/item/value", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_permission,
       { "permission", "dap.permission",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ModifyRights/_item/permission", HFILL }},
+        "dap.T_permission", HFILL }},
     { &hf_dap_purported,
       { "purported", "dap.purported",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgumentData/purported", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_unsignedCompareArgument,
       { "unsignedCompareArgument", "dap.unsignedCompareArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgument/unsignedCompareArgument", HFILL }},
+        "dap.CompareArgumentData", HFILL }},
     { &hf_dap_signedCompareArgument,
       { "signedCompareArgument", "dap.signedCompareArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgument/signedCompareArgument", HFILL }},
+        "dap.T_signedCompareArgument", HFILL }},
     { &hf_dap_compareArgument,
       { "compareArgument", "dap.compareArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgument/signedCompareArgument/compareArgument", HFILL }},
+        "dap.CompareArgumentData", HFILL }},
     { &hf_dap_matched,
       { "matched", "dap.matched",
         FT_BOOLEAN, 8, NULL, 0,
-        "CompareResultData/matched", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_matchedSubtype,
       { "matchedSubtype", "dap.matchedSubtype",
         FT_OID, BASE_NONE, NULL, 0,
-        "CompareResultData/matchedSubtype", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_unsignedCompareResult,
       { "unsignedCompareResult", "dap.unsignedCompareResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareResult/unsignedCompareResult", HFILL }},
+        "dap.CompareResultData", HFILL }},
     { &hf_dap_signedCompareResult,
       { "signedCompareResult", "dap.signedCompareResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareResult/signedCompareResult", HFILL }},
+        "dap.T_signedCompareResult", HFILL }},
     { &hf_dap_compareResult,
       { "compareResult", "dap.compareResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareResult/signedCompareResult/compareResult", HFILL }},
+        "dap.CompareResultData", HFILL }},
     { &hf_dap_invokeID,
       { "invokeID", "dap.invokeID",
         FT_UINT32, BASE_DEC, VALS(ros_InvokeId_vals), 0,
-        "", HFILL }},
+        "ros.InvokeId", HFILL }},
     { &hf_dap_unsignedAbandonArgument,
       { "unsignedAbandonArgument", "dap.unsignedAbandonArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonArgument/unsignedAbandonArgument", HFILL }},
+        "dap.AbandonArgumentData", HFILL }},
     { &hf_dap_signedAbandonArgument,
       { "signedAbandonArgument", "dap.signedAbandonArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonArgument/signedAbandonArgument", HFILL }},
+        "dap.T_signedAbandonArgument", HFILL }},
     { &hf_dap_abandonArgument,
       { "abandonArgument", "dap.abandonArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonArgument/signedAbandonArgument/abandonArgument", HFILL }},
+        "dap.AbandonArgumentData", HFILL }},
     { &hf_dap_null,
       { "null", "dap.null",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_abandon_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_AbandonInformation_vals), 0,
-        "AbandonResult/information", HFILL }},
+        "dap.AbandonInformation", HFILL }},
     { &hf_dap_unsignedAbandonResult,
       { "unsignedAbandonResult", "dap.unsignedAbandonResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonResult/information/unsignedAbandonResult", HFILL }},
+        "dap.AbandonResultData", HFILL }},
     { &hf_dap_signedAbandonResult,
       { "signedAbandonResult", "dap.signedAbandonResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonResult/information/signedAbandonResult", HFILL }},
+        "dap.T_signedAbandonResult", HFILL }},
     { &hf_dap_abandonResult,
       { "abandonResult", "dap.abandonResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonResult/information/signedAbandonResult/abandonResult", HFILL }},
+        "dap.AbandonResultData", HFILL }},
     { &hf_dap_pagedResults,
       { "pagedResults", "dap.pagedResults",
         FT_UINT32, BASE_DEC, VALS(dap_PagedResultsRequest_vals), 0,
-        "", HFILL }},
+        "dap.PagedResultsRequest", HFILL }},
     { &hf_dap_listFamily,
       { "listFamily", "dap.listFamily",
         FT_BOOLEAN, 8, NULL, 0,
-        "ListArgumentData/listFamily", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_unsignedListArgument,
       { "unsignedListArgument", "dap.unsignedListArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListArgument/unsignedListArgument", HFILL }},
+        "dap.ListArgumentData", HFILL }},
     { &hf_dap_signedListArgument,
       { "signedListArgument", "dap.signedListArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListArgument/signedListArgument", HFILL }},
+        "dap.T_signedListArgument", HFILL }},
     { &hf_dap_listArgument,
       { "listArgument", "dap.listArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListArgument/signedListArgument/listArgument", HFILL }},
+        "dap.ListArgumentData", HFILL }},
     { &hf_dap_listInfo,
       { "listInfo", "dap.listInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListResultData/listInfo", HFILL }},
+        "dap.T_listInfo", HFILL }},
     { &hf_dap_subordinates,
       { "subordinates", "dap.subordinates",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ListResultData/listInfo/subordinates", HFILL }},
+        "dap.T_subordinates", HFILL }},
     { &hf_dap_subordinates_item,
       { "Item", "dap.subordinates_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListResultData/listInfo/subordinates/_item", HFILL }},
+        "dap.T_subordinates_item", HFILL }},
     { &hf_dap_aliasEntry,
       { "aliasEntry", "dap.aliasEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "ListResultData/listInfo/subordinates/_item/aliasEntry", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_partialOutcomeQualifier,
       { "partialOutcomeQualifier", "dap.partialOutcomeQualifier",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.PartialOutcomeQualifier", HFILL }},
     { &hf_dap_uncorrelatedListInfo,
       { "uncorrelatedListInfo", "dap.uncorrelatedListInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ListResultData/uncorrelatedListInfo", HFILL }},
+        "dap.SET_OF_ListResult", HFILL }},
     { &hf_dap_uncorrelatedListInfo_item,
       { "Item", "dap.uncorrelatedListInfo_item",
         FT_UINT32, BASE_DEC, VALS(dap_ListResult_vals), 0,
-        "ListResultData/uncorrelatedListInfo/_item", HFILL }},
+        "dap.ListResult", HFILL }},
     { &hf_dap_unsignedListResult,
       { "unsignedListResult", "dap.unsignedListResult",
         FT_UINT32, BASE_DEC, VALS(dap_ListResultData_vals), 0,
-        "ListResult/unsignedListResult", HFILL }},
+        "dap.ListResultData", HFILL }},
     { &hf_dap_signedListResult,
       { "signedListResult", "dap.signedListResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListResult/signedListResult", HFILL }},
+        "dap.T_signedListResult", HFILL }},
     { &hf_dap_listResult,
       { "listResult", "dap.listResult",
         FT_UINT32, BASE_DEC, VALS(dap_ListResultData_vals), 0,
-        "ListResult/signedListResult/listResult", HFILL }},
+        "dap.ListResultData", HFILL }},
     { &hf_dap_limitProblem,
       { "limitProblem", "dap.limitProblem",
         FT_INT32, BASE_DEC, VALS(dap_LimitProblem_vals), 0,
-        "PartialOutcomeQualifier/limitProblem", HFILL }},
+        "dap.LimitProblem", HFILL }},
     { &hf_dap_unexplored,
       { "unexplored", "dap.unexplored",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/unexplored", HFILL }},
+        "dap.SET_OF_ContinuationReference", HFILL }},
     { &hf_dap_unexplored_item,
       { "Item", "dap.unexplored_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PartialOutcomeQualifier/unexplored/_item", HFILL }},
+        "dsp.ContinuationReference", HFILL }},
     { &hf_dap_unavailableCriticalExtensions,
       { "unavailableCriticalExtensions", "dap.unavailableCriticalExtensions",
         FT_BOOLEAN, 8, NULL, 0,
-        "PartialOutcomeQualifier/unavailableCriticalExtensions", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_unknownErrors,
       { "unknownErrors", "dap.unknownErrors",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/unknownErrors", HFILL }},
+        "dap.T_unknownErrors", HFILL }},
     { &hf_dap_unknownErrors_item,
       { "Item", "dap.unknownErrors_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "PartialOutcomeQualifier/unknownErrors/_item", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_overspecFilter,
       { "overspecFilter", "dap.overspecFilter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "PartialOutcomeQualifier/overspecFilter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_entryCount,
       { "entryCount", "dap.entryCount",
         FT_UINT32, BASE_DEC, VALS(dap_T_entryCount_vals), 0,
-        "PartialOutcomeQualifier/entryCount", HFILL }},
+        "dap.T_entryCount", HFILL }},
     { &hf_dap_bestEstimate,
       { "bestEstimate", "dap.bestEstimate",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/entryCount/bestEstimate", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_lowEstimate,
       { "lowEstimate", "dap.lowEstimate",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/entryCount/lowEstimate", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_baseObject,
       { "baseObject", "dap.baseObject",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "SearchArgumentData/baseObject", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_subset,
       { "subset", "dap.subset",
         FT_INT32, BASE_DEC, VALS(dap_T_subset_vals), 0,
-        "SearchArgumentData/subset", HFILL }},
+        "dap.T_subset", HFILL }},
     { &hf_dap_filter,
       { "filter", "dap.filter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "SearchArgumentData/filter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_searchAliases,
       { "searchAliases", "dap.searchAliases",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchArgumentData/searchAliases", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_matchedValuesOnly,
       { "matchedValuesOnly", "dap.matchedValuesOnly",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchArgumentData/matchedValuesOnly", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_extendedFilter,
       { "extendedFilter", "dap.extendedFilter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "SearchArgumentData/extendedFilter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_checkOverspecified,
       { "checkOverspecified", "dap.checkOverspecified",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchArgumentData/checkOverspecified", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_relaxation,
       { "relaxation", "dap.relaxation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgumentData/relaxation", HFILL }},
+        "x509if.RelaxationPolicy", HFILL }},
     { &hf_dap_extendedArea,
       { "extendedArea", "dap.extendedArea",
         FT_INT32, BASE_DEC, NULL, 0,
-        "SearchArgumentData/extendedArea", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_hierarchySelections,
       { "hierarchySelections", "dap.hierarchySelections",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SearchArgumentData/hierarchySelections", HFILL }},
+        "dap.HierarchySelections", HFILL }},
     { &hf_dap_searchControlOptions,
       { "searchControlOptions", "dap.searchControlOptions",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SearchArgumentData/searchControlOptions", HFILL }},
+        "dap.SearchControlOptions", HFILL }},
     { &hf_dap_joinArguments,
       { "joinArguments", "dap.joinArguments",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SearchArgumentData/joinArguments", HFILL }},
+        "dap.SEQUENCE_SIZE_1_MAX_OF_JoinArgument", HFILL }},
     { &hf_dap_joinArguments_item,
       { "Item", "dap.joinArguments_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgumentData/joinArguments/_item", HFILL }},
+        "dap.JoinArgument", HFILL }},
     { &hf_dap_joinType,
       { "joinType", "dap.joinType",
         FT_UINT32, BASE_DEC, VALS(dap_T_joinType_vals), 0,
-        "SearchArgumentData/joinType", HFILL }},
+        "dap.T_joinType", HFILL }},
     { &hf_dap_unsignedSearchArgument,
       { "unsignedSearchArgument", "dap.unsignedSearchArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgument/unsignedSearchArgument", HFILL }},
+        "dap.SearchArgumentData", HFILL }},
     { &hf_dap_signedSearchArgument,
       { "signedSearchArgument", "dap.signedSearchArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgument/signedSearchArgument", HFILL }},
+        "dap.T_signedSearchArgument", HFILL }},
     { &hf_dap_searchArgument,
       { "searchArgument", "dap.searchArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgument/signedSearchArgument/searchArgument", HFILL }},
+        "dap.SearchArgumentData", HFILL }},
     { &hf_dap_joinBaseObject,
       { "joinBaseObject", "dap.joinBaseObject",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "JoinArgument/joinBaseObject", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_domainLocalID,
       { "domainLocalID", "dap.domainLocalID",
         FT_UINT32, BASE_DEC, VALS(x509sat_DirectoryString_vals), 0,
-        "JoinArgument/domainLocalID", HFILL }},
+        "dap.DomainLocalID", HFILL }},
     { &hf_dap_joinSubset,
       { "joinSubset", "dap.joinSubset",
         FT_UINT32, BASE_DEC, VALS(dap_T_joinSubset_vals), 0,
-        "JoinArgument/joinSubset", HFILL }},
+        "dap.T_joinSubset", HFILL }},
     { &hf_dap_joinFilter,
       { "joinFilter", "dap.joinFilter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "JoinArgument/joinFilter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_joinAttributes,
       { "joinAttributes", "dap.joinAttributes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "JoinArgument/joinAttributes", HFILL }},
+        "dap.SEQUENCE_OF_JoinAttPair", HFILL }},
     { &hf_dap_joinAttributes_item,
       { "Item", "dap.joinAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "JoinArgument/joinAttributes/_item", HFILL }},
+        "dap.JoinAttPair", HFILL }},
     { &hf_dap_joinSelection,
       { "joinSelection", "dap.joinSelection",
         FT_NONE, BASE_NONE, NULL, 0,
-        "JoinArgument/joinSelection", HFILL }},
+        "dap.EntryInformationSelection", HFILL }},
     { &hf_dap_baseAtt,
       { "baseAtt", "dap.baseAtt",
         FT_OID, BASE_NONE, NULL, 0,
-        "JoinAttPair/baseAtt", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_joinAtt,
       { "joinAtt", "dap.joinAtt",
         FT_OID, BASE_NONE, NULL, 0,
-        "JoinAttPair/joinAtt", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_joinContext,
       { "joinContext", "dap.joinContext",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "JoinAttPair/joinContext", HFILL }},
+        "dap.SEQUENCE_OF_JoinContextType", HFILL }},
     { &hf_dap_joinContext_item,
       { "Item", "dap.joinContext_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "JoinAttPair/joinContext/_item", HFILL }},
+        "dap.JoinContextType", HFILL }},
     { &hf_dap_searchInfo,
       { "searchInfo", "dap.searchInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchResultData/searchInfo", HFILL }},
+        "dap.T_searchInfo", HFILL }},
     { &hf_dap_entries,
       { "entries", "dap.entries",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SearchResultData/searchInfo/entries", HFILL }},
+        "dap.SET_OF_EntryInformation", HFILL }},
     { &hf_dap_entries_item,
       { "Item", "dap.entries_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchResultData/searchInfo/entries/_item", HFILL }},
+        "dap.EntryInformation", HFILL }},
     { &hf_dap_altMatching,
       { "altMatching", "dap.altMatching",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchResultData/searchInfo/altMatching", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_uncorrelatedSearchInfo,
       { "uncorrelatedSearchInfo", "dap.uncorrelatedSearchInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SearchResultData/uncorrelatedSearchInfo", HFILL }},
+        "dap.SET_OF_SearchResult", HFILL }},
     { &hf_dap_uncorrelatedSearchInfo_item,
       { "Item", "dap.uncorrelatedSearchInfo_item",
         FT_UINT32, BASE_DEC, VALS(dap_SearchResult_vals), 0,
-        "SearchResultData/uncorrelatedSearchInfo/_item", HFILL }},
+        "dap.SearchResult", HFILL }},
     { &hf_dap_unsignedSearchResult,
       { "unsignedSearchResult", "dap.unsignedSearchResult",
         FT_UINT32, BASE_DEC, VALS(dap_SearchResultData_vals), 0,
-        "SearchResult/unsignedSearchResult", HFILL }},
+        "dap.SearchResultData", HFILL }},
     { &hf_dap_signedSearchResult,
       { "signedSearchResult", "dap.signedSearchResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchResult/signedSearchResult", HFILL }},
+        "dap.T_signedSearchResult", HFILL }},
     { &hf_dap_searchResult,
       { "searchResult", "dap.searchResult",
         FT_UINT32, BASE_DEC, VALS(dap_SearchResultData_vals), 0,
-        "SearchResult/signedSearchResult/searchResult", HFILL }},
+        "dap.SearchResultData", HFILL }},
     { &hf_dap_add_entry,
       { "entry", "dap.entry",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AddEntryArgumentData/entry", HFILL }},
+        "dap.SET_OF_Attribute", HFILL }},
     { &hf_dap_add_entry_item,
       { "Item", "dap.entry_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgumentData/entry/_item", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_targetSystem,
       { "targetSystem", "dap.targetSystem",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgumentData/targetSystem", HFILL }},
+        "dsp.AccessPoint", HFILL }},
     { &hf_dap_unsignedAddEntryArgument,
       { "unsignedAddEntryArgument", "dap.unsignedAddEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgument/unsignedAddEntryArgument", HFILL }},
+        "dap.AddEntryArgumentData", HFILL }},
     { &hf_dap_signedAddEntryArgument,
       { "signedAddEntryArgument", "dap.signedAddEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgument/signedAddEntryArgument", HFILL }},
+        "dap.T_signedAddEntryArgument", HFILL }},
     { &hf_dap_addEntryArgument,
       { "addEntryArgument", "dap.addEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgument/signedAddEntryArgument/addEntryArgument", HFILL }},
+        "dap.AddEntryArgumentData", HFILL }},
     { &hf_dap_add_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_AddEntryInformation_vals), 0,
-        "AddEntryResult/information", HFILL }},
+        "dap.AddEntryInformation", HFILL }},
     { &hf_dap_unsignedAddEntryResult,
       { "unsignedAddEntryResult", "dap.unsignedAddEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryResult/information/unsignedAddEntryResult", HFILL }},
+        "dap.AddEntryResultData", HFILL }},
     { &hf_dap_signedAddEntryResult,
       { "signedAddEntryResult", "dap.signedAddEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryResult/information/signedAddEntryResult", HFILL }},
+        "dap.T_signedAddEntryResult", HFILL }},
     { &hf_dap_addEntryResult,
       { "addEntryResult", "dap.addEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryResult/information/signedAddEntryResult/addEntryResult", HFILL }},
+        "dap.AddEntryResultData", HFILL }},
     { &hf_dap_unsignedRemoveEntryArgument,
       { "unsignedRemoveEntryArgument", "dap.unsignedRemoveEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryArgument/unsignedRemoveEntryArgument", HFILL }},
+        "dap.RemoveEntryArgumentData", HFILL }},
     { &hf_dap_signedRemoveEntryArgument,
       { "signedRemoveEntryArgument", "dap.signedRemoveEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryArgument/signedRemoveEntryArgument", HFILL }},
+        "dap.T_signedRemoveEntryArgument", HFILL }},
     { &hf_dap_removeEntryArgument,
       { "removeEntryArgument", "dap.removeEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryArgument/signedRemoveEntryArgument/removeEntryArgument", HFILL }},
+        "dap.RemoveEntryArgumentData", HFILL }},
     { &hf_dap_remove_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_RemoveEntryInformation_vals), 0,
-        "RemoveEntryResult/information", HFILL }},
+        "dap.RemoveEntryInformation", HFILL }},
     { &hf_dap_unsignedRemoveEntryResult,
       { "unsignedRemoveEntryResult", "dap.unsignedRemoveEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryResult/information/unsignedRemoveEntryResult", HFILL }},
+        "dap.RemoveEntryResultData", HFILL }},
     { &hf_dap_signedRemoveEntryResult,
       { "signedRemoveEntryResult", "dap.signedRemoveEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryResult/information/signedRemoveEntryResult", HFILL }},
+        "dap.T_signedRemoveEntryResult", HFILL }},
     { &hf_dap_removeEntryResult,
       { "removeEntryResult", "dap.removeEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryResult/information/signedRemoveEntryResult/removeEntryResult", HFILL }},
+        "dap.RemoveEntryResultData", HFILL }},
     { &hf_dap_changes,
       { "changes", "dap.changes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ModifyEntryArgumentData/changes", HFILL }},
+        "dap.SEQUENCE_OF_EntryModification", HFILL }},
     { &hf_dap_changes_item,
       { "Item", "dap.changes_item",
         FT_UINT32, BASE_DEC, VALS(dap_EntryModification_vals), 0,
-        "ModifyEntryArgumentData/changes/_item", HFILL }},
+        "dap.EntryModification", HFILL }},
     { &hf_dap_unsignedModifyEntryArgument,
       { "unsignedModifyEntryArgument", "dap.unsignedModifyEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryArgument/unsignedModifyEntryArgument", HFILL }},
+        "dap.ModifyEntryArgumentData", HFILL }},
     { &hf_dap_signedModifyEntryArgument,
       { "signedModifyEntryArgument", "dap.signedModifyEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryArgument/signedModifyEntryArgument", HFILL }},
+        "dap.T_signedModifyEntryArgument", HFILL }},
     { &hf_dap_modifyEntryArgument,
       { "modifyEntryArgument", "dap.modifyEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryArgument/signedModifyEntryArgument/modifyEntryArgument", HFILL }},
+        "dap.ModifyEntryArgumentData", HFILL }},
     { &hf_dap_modify_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_ModifyEntryInformation_vals), 0,
-        "ModifyEntryResult/information", HFILL }},
+        "dap.ModifyEntryInformation", HFILL }},
     { &hf_dap_unsignedModifyEntryResult,
       { "unsignedModifyEntryResult", "dap.unsignedModifyEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryResult/information/unsignedModifyEntryResult", HFILL }},
+        "dap.ModifyEntryResultData", HFILL }},
     { &hf_dap_signedModifyEntryResult,
       { "signedModifyEntryResult", "dap.signedModifyEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryResult/information/signedModifyEntryResult", HFILL }},
+        "dap.T_signedModifyEntryResult", HFILL }},
     { &hf_dap_modifyEntryResult,
       { "modifyEntryResult", "dap.modifyEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryResult/information/signedModifyEntryResult/modifyEntryResult", HFILL }},
+        "dap.ModifyEntryResultData", HFILL }},
     { &hf_dap_addAttribute,
       { "addAttribute", "dap.addAttribute",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/addAttribute", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_removeAttribute,
       { "removeAttribute", "dap.removeAttribute",
         FT_OID, BASE_NONE, NULL, 0,
-        "EntryModification/removeAttribute", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_addValues,
       { "addValues", "dap.addValues",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/addValues", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_removeValues,
       { "removeValues", "dap.removeValues",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/removeValues", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_alterValues,
       { "alterValues", "dap.alterValues",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/alterValues", HFILL }},
+        "crmf.AttributeTypeAndValue", HFILL }},
     { &hf_dap_resetValue,
       { "resetValue", "dap.resetValue",
         FT_OID, BASE_NONE, NULL, 0,
-        "EntryModification/resetValue", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_newRDN,
       { "newRDN", "dap.newRDN",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.RelativeDistinguishedName", HFILL }},
     { &hf_dap_deleteOldRDN,
       { "deleteOldRDN", "dap.deleteOldRDN",
         FT_BOOLEAN, 8, NULL, 0,
-        "ModifyDNArgument/deleteOldRDN", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_newSuperior,
       { "newSuperior", "dap.newSuperior",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ModifyDNArgument/newSuperior", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_modify_dn_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_ModifyDNInformation_vals), 0,
-        "ModifyDNResult/information", HFILL }},
+        "dap.ModifyDNInformation", HFILL }},
     { &hf_dap_unsignedModifyDNResult,
       { "unsignedModifyDNResult", "dap.unsignedModifyDNResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyDNResult/information/unsignedModifyDNResult", HFILL }},
+        "dap.ModifyDNResultData", HFILL }},
     { &hf_dap_signedModifyDNResult,
       { "signedModifyDNResult", "dap.signedModifyDNResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyDNResult/information/signedModifyDNResult", HFILL }},
+        "dap.T_signedModifyDNResult", HFILL }},
     { &hf_dap_modifyDNResult,
       { "modifyDNResult", "dap.modifyDNResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyDNResult/information/signedModifyDNResult/modifyDNResult", HFILL }},
+        "dap.ModifyDNResultData", HFILL }},
     { &hf_dap_unsignedAbandoned,
       { "unsignedAbandoned", "dap.unsignedAbandoned",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Abandoned/unsignedAbandoned", HFILL }},
+        "dap.AbandonedData", HFILL }},
     { &hf_dap_signedAbandoned,
       { "signedAbandoned", "dap.signedAbandoned",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Abandoned/signedAbandoned", HFILL }},
+        "dap.T_signedAbandoned", HFILL }},
     { &hf_dap_abandoned,
       { "abandoned", "dap.abandoned",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Abandoned/signedAbandoned/abandoned", HFILL }},
+        "dap.AbandonedData", HFILL }},
     { &hf_dap_abandon_failed_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_AbandonProblem_vals), 0,
-        "AbandonFailedErrorData/problem", HFILL }},
+        "dap.AbandonProblem", HFILL }},
     { &hf_dap_operation,
       { "operation", "dap.operation",
         FT_UINT32, BASE_DEC, VALS(ros_InvokeId_vals), 0,
-        "AbandonFailedErrorData/operation", HFILL }},
+        "ros.InvokeId", HFILL }},
     { &hf_dap_unsignedAbandonFailedError,
       { "unsignedAbandonFailedError", "dap.unsignedAbandonFailedError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonFailedError/unsignedAbandonFailedError", HFILL }},
+        "dap.AbandonFailedErrorData", HFILL }},
     { &hf_dap_signedAbandonFailedError,
       { "signedAbandonFailedError", "dap.signedAbandonFailedError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonFailedError/signedAbandonFailedError", HFILL }},
+        "dap.T_signedAbandonFailedError", HFILL }},
     { &hf_dap_abandonFailedError,
       { "abandonFailedError", "dap.abandonFailedError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonFailedError/signedAbandonFailedError/abandonFailedError", HFILL }},
+        "dap.AbandonFailedErrorData", HFILL }},
     { &hf_dap_problems,
       { "problems", "dap.problems",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AttributeErrorData/problems", HFILL }},
+        "dap.T_problems", HFILL }},
     { &hf_dap_problems_item,
       { "Item", "dap.problems_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeErrorData/problems/_item", HFILL }},
+        "dap.T_problems_item", HFILL }},
     { &hf_dap_attribute_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_AttributeProblem_vals), 0,
-        "AttributeErrorData/problems/_item/problem", HFILL }},
+        "dap.AttributeProblem", HFILL }},
     { &hf_dap_value,
       { "value", "dap.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeErrorData/problems/_item/value", HFILL }},
+        "x509if.AttributeValue", HFILL }},
     { &hf_dap_unsignedAttributeError,
       { "unsignedAttributeError", "dap.unsignedAttributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/unsignedAttributeError", HFILL }},
+        "dap.AttributeErrorData", HFILL }},
     { &hf_dap_signedAttributeError,
       { "signedAttributeError", "dap.signedAttributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/signedAttributeError", HFILL }},
+        "dap.T_signedAttributeError", HFILL }},
     { &hf_dap_attributeError,
       { "attributeError", "dap.attributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/signedAttributeError/attributeError", HFILL }},
+        "dap.AttributeErrorData", HFILL }},
     { &hf_dap_name_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_NameProblem_vals), 0,
-        "NameErrorData/problem", HFILL }},
+        "dap.NameProblem", HFILL }},
     { &hf_dap_matched_name,
       { "matched", "dap.matched",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "NameErrorData/matched", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_unsignedNameError,
       { "unsignedNameError", "dap.unsignedNameError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NameError/unsignedNameError", HFILL }},
+        "dap.NameErrorData", HFILL }},
     { &hf_dap_signedNameError,
       { "signedNameError", "dap.signedNameError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NameError/signedNameError", HFILL }},
+        "dap.T_signedNameError", HFILL }},
     { &hf_dap_nameError,
       { "nameError", "dap.nameError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NameError/signedNameError/nameError", HFILL }},
+        "dap.NameErrorData", HFILL }},
     { &hf_dap_candidate,
       { "candidate", "dap.candidate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReferralData/candidate", HFILL }},
+        "dsp.ContinuationReference", HFILL }},
     { &hf_dap_unsignedReferral,
       { "unsignedReferral", "dap.unsignedReferral",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Referral/unsignedReferral", HFILL }},
+        "dap.ReferralData", HFILL }},
     { &hf_dap_signedReferral,
       { "signedReferral", "dap.signedReferral",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Referral/signedReferral", HFILL }},
+        "dap.T_signedReferral", HFILL }},
     { &hf_dap_referral,
       { "referral", "dap.referral",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Referral/signedReferral/referral", HFILL }},
+        "dap.ReferralData", HFILL }},
     { &hf_dap_security_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_SecurityProblem_vals), 0,
-        "SecurityErrorData/problem", HFILL }},
+        "dap.SecurityProblem", HFILL }},
     { &hf_dap_spkmInfo,
       { "spkmInfo", "dap.spkmInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityErrorData/spkmInfo", HFILL }},
+        "dap.T_spkmInfo", HFILL }},
     { &hf_dap_unsignedSecurityError,
       { "unsignedSecurityError", "dap.unsignedSecurityError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityError/unsignedSecurityError", HFILL }},
+        "dap.SecurityErrorData", HFILL }},
     { &hf_dap_signedSecurityError,
       { "signedSecurityError", "dap.signedSecurityError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityError/signedSecurityError", HFILL }},
+        "dap.T_signedSecurityError", HFILL }},
     { &hf_dap_securityErrorData,
       { "securityError", "dap.securityError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityError/signedSecurityError/securityError", HFILL }},
+        "dap.SecurityErrorData", HFILL }},
     { &hf_dap_service_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_ServiceProblem_vals), 0,
-        "ServiceErrorData/problem", HFILL }},
+        "dap.ServiceProblem", HFILL }},
     { &hf_dap_unsignedServiceError,
       { "unsignedServiceError", "dap.unsignedServiceError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceError/unsignedServiceError", HFILL }},
+        "dap.ServiceErrorData", HFILL }},
     { &hf_dap_signedServiceError,
       { "signedServiceError", "dap.signedServiceError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceError/signedServiceError", HFILL }},
+        "dap.T_signedServiceError", HFILL }},
     { &hf_dap_serviceError,
       { "serviceError", "dap.serviceError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceError/signedServiceError/serviceError", HFILL }},
+        "dap.ServiceErrorData", HFILL }},
     { &hf_dap_update_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_UpdateProblem_vals), 0,
-        "UpdateErrorData/problem", HFILL }},
+        "dap.UpdateProblem", HFILL }},
     { &hf_dap_attributeInfo,
       { "attributeInfo", "dap.attributeInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "UpdateErrorData/attributeInfo", HFILL }},
+        "dap.T_attributeInfo", HFILL }},
     { &hf_dap_attributeInfo_item,
       { "Item", "dap.attributeInfo_item",
         FT_UINT32, BASE_DEC, VALS(dap_T_attributeInfo_item_vals), 0,
-        "UpdateErrorData/attributeInfo/_item", HFILL }},
+        "dap.T_attributeInfo_item", HFILL }},
     { &hf_dap_unsignedUpdateError,
       { "unsignedUpdateError", "dap.unsignedUpdateError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateError/unsignedUpdateError", HFILL }},
+        "dap.UpdateErrorData", HFILL }},
     { &hf_dap_signedUpdateError,
       { "signedUpdateError", "dap.signedUpdateError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateError/signedUpdateError", HFILL }},
+        "dap.T_signedUpdateError", HFILL }},
     { &hf_dap_updateError,
       { "updateError", "dap.updateError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateError/signedUpdateError/updateError", HFILL }},
+        "dap.UpdateErrorData", HFILL }},
     { &hf_dap_ServiceControlOptions_preferChaining,
       { "preferChaining", "dap.preferChaining",
         FT_BOOLEAN, 8, NULL, 0x80,