e2sim/src/ASN1c/ProtocolIE-Field.c

   1 /*
   2  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
   3  * From ASN.1 module "E2AP-Containers"
   4  *      found in "e2ap-v01.01.00.asn"
   5  *      `asn1c -pdu=auto -fincludes-quoted -fcompound-names -findirect-choice -fno-include-deps -gen-PER -no-gen-OER -no-gen-example`
   6  */
   7
   8 #include "ProtocolIE-Field.h"
   9
  10 static const long asn_VAL_4_id_RICaction_ToBeSetup_Item = 19;
  11 static const long asn_VAL_4_ignore = 1;
  12 static const long asn_VAL_4_mandatory = 2;
  13 static const asn_ioc_cell_t asn_IOS_RICaction_ToBeSetup_ItemIEs_1_rows[] = {
  14         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_4_id_RICaction_ToBeSetup_Item },
  15         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_4_ignore },
  16         { "&Value", aioc__type, &asn_DEF_RICaction_ToBeSetup_Item },
  17         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_4_mandatory }
  18 };
  19 static const asn_ioc_set_t asn_IOS_RICaction_ToBeSetup_ItemIEs_1[] = {
  20         { 1, 4, asn_IOS_RICaction_ToBeSetup_ItemIEs_1_rows }
  21 };
  22 static const long asn_VAL_9_id_RICaction_Admitted_Item = 14;
  23 static const long asn_VAL_9_ignore = 1;
  24 static const long asn_VAL_9_mandatory = 2;
  25 static const asn_ioc_cell_t asn_IOS_RICaction_Admitted_ItemIEs_1_rows[] = {
  26         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_9_id_RICaction_Admitted_Item },
  27         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_9_ignore },
  28         { "&Value", aioc__type, &asn_DEF_RICaction_Admitted_Item },
  29         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_9_mandatory }
  30 };
  31 static const asn_ioc_set_t asn_IOS_RICaction_Admitted_ItemIEs_1[] = {
  32         { 1, 4, asn_IOS_RICaction_Admitted_ItemIEs_1_rows }
  33 };
  34 static const long asn_VAL_10_id_RICaction_NotAdmitted_Item = 16;
  35 static const long asn_VAL_10_ignore = 1;
  36 static const long asn_VAL_10_mandatory = 2;
  37 static const asn_ioc_cell_t asn_IOS_RICaction_NotAdmitted_ItemIEs_1_rows[] = {
  38         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_10_id_RICaction_NotAdmitted_Item },
  39         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_10_ignore },
  40         { "&Value", aioc__type, &asn_DEF_RICaction_NotAdmitted_Item },
  41         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_10_mandatory }
  42 };
  43 static const asn_ioc_set_t asn_IOS_RICaction_NotAdmitted_ItemIEs_1[] = {
  44         { 1, 4, asn_IOS_RICaction_NotAdmitted_ItemIEs_1_rows }
  45 };
  46 static const long asn_VAL_65_id_E2connectionUpdate_Item = 43;
  47 static const long asn_VAL_65_ignore = 1;
  48 static const long asn_VAL_65_mandatory = 2;
  49 static const asn_ioc_cell_t asn_IOS_E2connectionUpdate_ItemIEs_1_rows[] = {
  50         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_65_id_E2connectionUpdate_Item },
  51         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_65_ignore },
  52         { "&Value", aioc__type, &asn_DEF_E2connectionUpdate_Item },
  53         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_65_mandatory }
  54 };
  55 static const asn_ioc_set_t asn_IOS_E2connectionUpdate_ItemIEs_1[] = {
  56         { 1, 4, asn_IOS_E2connectionUpdate_ItemIEs_1_rows }
  57 };
  58 static const long asn_VAL_66_id_E2connectionUpdateRemove_Item = 47;
  59 static const long asn_VAL_66_ignore = 1;
  60 static const long asn_VAL_66_mandatory = 2;
  61 static const asn_ioc_cell_t asn_IOS_E2connectionUpdateRemove_ItemIEs_1_rows[] = {
  62         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_66_id_E2connectionUpdateRemove_Item },
  63         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_66_ignore },
  64         { "&Value", aioc__type, &asn_DEF_E2connectionUpdateRemove_Item },
  65         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_66_mandatory }
  66 };
  67 static const asn_ioc_set_t asn_IOS_E2connectionUpdateRemove_ItemIEs_1[] = {
  68         { 1, 4, asn_IOS_E2connectionUpdateRemove_ItemIEs_1_rows }
  69 };
  70 static const long asn_VAL_69_id_E2connectionSetupFailed_Item = 41;
  71 static const long asn_VAL_69_ignore = 1;
  72 static const long asn_VAL_69_mandatory = 2;
  73 static const asn_ioc_cell_t asn_IOS_E2connectionSetupFailed_ItemIEs_1_rows[] = {
  74         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_69_id_E2connectionSetupFailed_Item },
  75         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_69_ignore },
  76         { "&Value", aioc__type, &asn_DEF_E2connectionSetupFailed_Item },
  77         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_69_mandatory }
  78 };
  79 static const asn_ioc_set_t asn_IOS_E2connectionSetupFailed_ItemIEs_1[] = {
  80         { 1, 4, asn_IOS_E2connectionSetupFailed_ItemIEs_1_rows }
  81 };
  82 static const long asn_VAL_74_id_E2nodeComponentConfigUpdate_Item = 34;
  83 static const long asn_VAL_74_reject = 0;
  84 static const long asn_VAL_74_mandatory = 2;
  85 static const asn_ioc_cell_t asn_IOS_E2nodeComponentConfigUpdate_ItemIEs_1_rows[] = {
  86         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_74_id_E2nodeComponentConfigUpdate_Item },
  87         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_74_reject },
  88         { "&Value", aioc__type, &asn_DEF_E2nodeComponentConfigUpdate_Item },
  89         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_74_mandatory }
  90 };
  91 static const asn_ioc_set_t asn_IOS_E2nodeComponentConfigUpdate_ItemIEs_1[] = {
  92         { 1, 4, asn_IOS_E2nodeComponentConfigUpdate_ItemIEs_1_rows }
  93 };
  94 static const long asn_VAL_76_id_E2nodeComponentConfigUpdateAck_Item = 36;
  95 static const long asn_VAL_76_reject = 0;
  96 static const long asn_VAL_76_mandatory = 2;
  97 static const asn_ioc_cell_t asn_IOS_E2nodeComponentConfigUpdateAck_ItemIEs_1_rows[] = {
  98         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_76_id_E2nodeComponentConfigUpdateAck_Item },
  99         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_76_reject },
 100         { "&Value", aioc__type, &asn_DEF_E2nodeComponentConfigUpdateAck_Item },
 101         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_76_mandatory }
 102 };
 103 static const asn_ioc_set_t asn_IOS_E2nodeComponentConfigUpdateAck_ItemIEs_1[] = {
 104         { 1, 4, asn_IOS_E2nodeComponentConfigUpdateAck_ItemIEs_1_rows }
 105 };
 106 static const long asn_VAL_85_id_RANfunction_Item = 8;
 107 static const long asn_VAL_85_ignore = 1;
 108 static const long asn_VAL_85_mandatory = 2;
 109 static const asn_ioc_cell_t asn_IOS_RANfunction_ItemIEs_1_rows[] = {
 110         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_85_id_RANfunction_Item },
 111         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_85_ignore },
 112         { "&Value", aioc__type, &asn_DEF_RANfunction_Item },
 113         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_85_mandatory }
 114 };
 115 static const asn_ioc_set_t asn_IOS_RANfunction_ItemIEs_1[] = {
 116         { 1, 4, asn_IOS_RANfunction_ItemIEs_1_rows }
 117 };
 118 static const long asn_VAL_86_id_RANfunctionID_Item = 6;
 119 static const long asn_VAL_86_ignore = 1;
 120 static const long asn_VAL_86_mandatory = 2;
 121 static const asn_ioc_cell_t asn_IOS_RANfunctionID_ItemIEs_1_rows[] = {
 122         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_86_id_RANfunctionID_Item },
 123         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_86_ignore },
 124         { "&Value", aioc__type, &asn_DEF_RANfunctionID_Item },
 125         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_86_mandatory }
 126 };
 127 static const asn_ioc_set_t asn_IOS_RANfunctionID_ItemIEs_1[] = {
 128         { 1, 4, asn_IOS_RANfunctionID_ItemIEs_1_rows }
 129 };
 130 static const long asn_VAL_89_id_RANfunctionIEcause_Item = 7;
 131 static const long asn_VAL_89_ignore = 1;
 132 static const long asn_VAL_89_mandatory = 2;
 133 static const asn_ioc_cell_t asn_IOS_RANfunctionIDcause_ItemIEs_1_rows[] = {
 134         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_89_id_RANfunctionIEcause_Item },
 135         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_89_ignore },
 136         { "&Value", aioc__type, &asn_DEF_RANfunctionIDcause_Item },
 137         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_89_mandatory }
 138 };
 139 static const asn_ioc_set_t asn_IOS_RANfunctionIDcause_ItemIEs_1[] = {
 140         { 1, 4, asn_IOS_RANfunctionIDcause_ItemIEs_1_rows }
 141 };
 142 static const long asn_VAL_1_id_RICrequestID = 29;
 143 static const long asn_VAL_1_reject = 0;
 144 static const long asn_VAL_1_mandatory = 2;
 145 static const long asn_VAL_2_id_RANfunctionID = 5;
 146 static const long asn_VAL_2_reject = 0;
 147 static const long asn_VAL_2_mandatory = 2;
 148 static const long asn_VAL_3_id_RICsubscriptionDetails = 30;
 149 static const long asn_VAL_3_reject = 0;
 150 static const long asn_VAL_3_mandatory = 2;
 151 static const asn_ioc_cell_t asn_IOS_RICsubscriptionRequest_IEs_1_rows[] = {
 152         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_1_id_RICrequestID },
 153         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_1_reject },
 154         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 155         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_1_mandatory },
 156         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_2_id_RANfunctionID },
 157         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_2_reject },
 158         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 159         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_2_mandatory },
 160         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_3_id_RICsubscriptionDetails },
 161         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_3_reject },
 162         { "&Value", aioc__type, &asn_DEF_RICsubscriptionDetails },
 163         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_3_mandatory }
 164 };
 165 static const asn_ioc_set_t asn_IOS_RICsubscriptionRequest_IEs_1[] = {
 166         { 3, 4, asn_IOS_RICsubscriptionRequest_IEs_1_rows }
 167 };
 168 static const long asn_VAL_5_id_RICrequestID = 29;
 169 static const long asn_VAL_5_reject = 0;
 170 static const long asn_VAL_5_mandatory = 2;
 171 static const long asn_VAL_6_id_RANfunctionID = 5;
 172 static const long asn_VAL_6_reject = 0;
 173 static const long asn_VAL_6_mandatory = 2;
 174 static const long asn_VAL_7_id_RICactions_Admitted = 17;
 175 static const long asn_VAL_7_reject = 0;
 176 static const long asn_VAL_7_mandatory = 2;
 177 static const long asn_VAL_8_id_RICactions_NotAdmitted = 18;
 178 static const long asn_VAL_8_reject = 0;
 179 static const long asn_VAL_8_optional = 0;
 180 static const asn_ioc_cell_t asn_IOS_RICsubscriptionResponse_IEs_1_rows[] = {
 181         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_5_id_RICrequestID },
 182         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_5_reject },
 183         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 184         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_5_mandatory },
 185         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_6_id_RANfunctionID },
 186         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_6_reject },
 187         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 188         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_6_mandatory },
 189         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_7_id_RICactions_Admitted },
 190         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_7_reject },
 191         { "&Value", aioc__type, &asn_DEF_RICaction_Admitted_List },
 192         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_7_mandatory },
 193         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_8_id_RICactions_NotAdmitted },
 194         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_8_reject },
 195         { "&Value", aioc__type, &asn_DEF_RICaction_NotAdmitted_List },
 196         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_8_optional }
 197 };
 198 static const asn_ioc_set_t asn_IOS_RICsubscriptionResponse_IEs_1[] = {
 199         { 4, 4, asn_IOS_RICsubscriptionResponse_IEs_1_rows }
 200 };
 201 static const long asn_VAL_11_id_RICrequestID = 29;
 202 static const long asn_VAL_11_reject = 0;
 203 static const long asn_VAL_11_mandatory = 2;
 204 static const long asn_VAL_12_id_RANfunctionID = 5;
 205 static const long asn_VAL_12_reject = 0;
 206 static const long asn_VAL_12_mandatory = 2;
 207 static const long asn_VAL_13_id_RICactions_NotAdmitted = 18;
 208 static const long asn_VAL_13_reject = 0;
 209 static const long asn_VAL_13_mandatory = 2;
 210 static const long asn_VAL_14_id_CriticalityDiagnostics = 2;
 211 static const long asn_VAL_14_ignore = 1;
 212 static const long asn_VAL_14_optional = 0;
 213 static const asn_ioc_cell_t asn_IOS_RICsubscriptionFailure_IEs_1_rows[] = {
 214         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_11_id_RICrequestID },
 215         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_11_reject },
 216         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 217         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_11_mandatory },
 218         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_12_id_RANfunctionID },
 219         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_12_reject },
 220         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 221         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_12_mandatory },
 222         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_13_id_RICactions_NotAdmitted },
 223         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_13_reject },
 224         { "&Value", aioc__type, &asn_DEF_RICaction_NotAdmitted_List },
 225         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_13_mandatory },
 226         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_14_id_CriticalityDiagnostics },
 227         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_14_ignore },
 228         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 229         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_14_optional }
 230 };
 231 static const asn_ioc_set_t asn_IOS_RICsubscriptionFailure_IEs_1[] = {
 232         { 4, 4, asn_IOS_RICsubscriptionFailure_IEs_1_rows }
 233 };
 234 static const long asn_VAL_15_id_RICrequestID = 29;
 235 static const long asn_VAL_15_reject = 0;
 236 static const long asn_VAL_15_mandatory = 2;
 237 static const long asn_VAL_16_id_RANfunctionID = 5;
 238 static const long asn_VAL_16_reject = 0;
 239 static const long asn_VAL_16_mandatory = 2;
 240 static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteRequest_IEs_1_rows[] = {
 241         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_15_id_RICrequestID },
 242         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_15_reject },
 243         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 244         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_15_mandatory },
 245         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_16_id_RANfunctionID },
 246         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_16_reject },
 247         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 248         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_16_mandatory }
 249 };
 250 static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteRequest_IEs_1[] = {
 251         { 2, 4, asn_IOS_RICsubscriptionDeleteRequest_IEs_1_rows }
 252 };
 253 static const long asn_VAL_17_id_RICrequestID = 29;
 254 static const long asn_VAL_17_reject = 0;
 255 static const long asn_VAL_17_mandatory = 2;
 256 static const long asn_VAL_18_id_RANfunctionID = 5;
 257 static const long asn_VAL_18_reject = 0;
 258 static const long asn_VAL_18_mandatory = 2;
 259 static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteResponse_IEs_1_rows[] = {
 260         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_17_id_RICrequestID },
 261         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_17_reject },
 262         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 263         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_17_mandatory },
 264         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_18_id_RANfunctionID },
 265         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_18_reject },
 266         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 267         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_18_mandatory }
 268 };
 269 static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteResponse_IEs_1[] = {
 270         { 2, 4, asn_IOS_RICsubscriptionDeleteResponse_IEs_1_rows }
 271 };
 272 static const long asn_VAL_19_id_RICrequestID = 29;
 273 static const long asn_VAL_19_reject = 0;
 274 static const long asn_VAL_19_mandatory = 2;
 275 static const long asn_VAL_20_id_RANfunctionID = 5;
 276 static const long asn_VAL_20_reject = 0;
 277 static const long asn_VAL_20_mandatory = 2;
 278 static const long asn_VAL_21_id_Cause = 1;
 279 static const long asn_VAL_21_ignore = 1;
 280 static const long asn_VAL_21_mandatory = 2;
 281 static const long asn_VAL_22_id_CriticalityDiagnostics = 2;
 282 static const long asn_VAL_22_ignore = 1;
 283 static const long asn_VAL_22_optional = 0;
 284 static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteFailure_IEs_1_rows[] = {
 285         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_19_id_RICrequestID },
 286         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_19_reject },
 287         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 288         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_19_mandatory },
 289         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_20_id_RANfunctionID },
 290         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_20_reject },
 291         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 292         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_20_mandatory },
 293         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_21_id_Cause },
 294         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_21_ignore },
 295         { "&Value", aioc__type, &asn_DEF_Cause },
 296         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_21_mandatory },
 297         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_22_id_CriticalityDiagnostics },
 298         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_22_ignore },
 299         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 300         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_22_optional }
 301 };
 302 static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteFailure_IEs_1[] = {
 303         { 4, 4, asn_IOS_RICsubscriptionDeleteFailure_IEs_1_rows }
 304 };
 305 static const long asn_VAL_23_id_RICrequestID = 29;
 306 static const long asn_VAL_23_reject = 0;
 307 static const long asn_VAL_23_mandatory = 2;
 308 static const long asn_VAL_24_id_RANfunctionID = 5;
 309 static const long asn_VAL_24_reject = 0;
 310 static const long asn_VAL_24_mandatory = 2;
 311 static const long asn_VAL_25_id_RICactionID = 15;
 312 static const long asn_VAL_25_reject = 0;
 313 static const long asn_VAL_25_mandatory = 2;
 314 static const long asn_VAL_26_id_RICindicationSN = 27;
 315 static const long asn_VAL_26_reject = 0;
 316 static const long asn_VAL_26_optional = 0;
 317 static const long asn_VAL_27_id_RICindicationType = 28;
 318 static const long asn_VAL_27_reject = 0;
 319 static const long asn_VAL_27_mandatory = 2;
 320 static const long asn_VAL_28_id_RICindicationHeader = 25;
 321 static const long asn_VAL_28_reject = 0;
 322 static const long asn_VAL_28_mandatory = 2;
 323 static const long asn_VAL_29_id_RICindicationMessage = 26;
 324 static const long asn_VAL_29_reject = 0;
 325 static const long asn_VAL_29_mandatory = 2;
 326 static const long asn_VAL_30_id_RICcallProcessID = 20;
 327 static const long asn_VAL_30_reject = 0;
 328 static const long asn_VAL_30_optional = 0;
 329 static const asn_ioc_cell_t asn_IOS_RICindication_IEs_1_rows[] = {
 330         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_23_id_RICrequestID },
 331         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_23_reject },
 332         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 333         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_23_mandatory },
 334         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_24_id_RANfunctionID },
 335         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_24_reject },
 336         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 337         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_24_mandatory },
 338         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_25_id_RICactionID },
 339         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_25_reject },
 340         { "&Value", aioc__type, &asn_DEF_RICactionID },
 341         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_25_mandatory },
 342         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_26_id_RICindicationSN },
 343         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_26_reject },
 344         { "&Value", aioc__type, &asn_DEF_RICindicationSN },
 345         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_26_optional },
 346         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_27_id_RICindicationType },
 347         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_27_reject },
 348         { "&Value", aioc__type, &asn_DEF_RICindicationType },
 349         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_27_mandatory },
 350         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_28_id_RICindicationHeader },
 351         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_28_reject },
 352         { "&Value", aioc__type, &asn_DEF_RICindicationHeader },
 353         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_28_mandatory },
 354         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_29_id_RICindicationMessage },
 355         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_29_reject },
 356         { "&Value", aioc__type, &asn_DEF_RICindicationMessage },
 357         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_29_mandatory },
 358         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_30_id_RICcallProcessID },
 359         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_30_reject },
 360         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 361         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_30_optional }
 362 };
 363 static const asn_ioc_set_t asn_IOS_RICindication_IEs_1[] = {
 364         { 8, 4, asn_IOS_RICindication_IEs_1_rows }
 365 };
 366 static const long asn_VAL_31_id_RICrequestID = 29;
 367 static const long asn_VAL_31_reject = 0;
 368 static const long asn_VAL_31_mandatory = 2;
 369 static const long asn_VAL_32_id_RANfunctionID = 5;
 370 static const long asn_VAL_32_reject = 0;
 371 static const long asn_VAL_32_mandatory = 2;
 372 static const long asn_VAL_33_id_RICcallProcessID = 20;
 373 static const long asn_VAL_33_reject = 0;
 374 static const long asn_VAL_33_optional = 0;
 375 static const long asn_VAL_34_id_RICcontrolHeader = 22;
 376 static const long asn_VAL_34_reject = 0;
 377 static const long asn_VAL_34_mandatory = 2;
 378 static const long asn_VAL_35_id_RICcontrolMessage = 23;
 379 static const long asn_VAL_35_reject = 0;
 380 static const long asn_VAL_35_mandatory = 2;
 381 static const long asn_VAL_36_id_RICcontrolAckRequest = 21;
 382 static const long asn_VAL_36_reject = 0;
 383 static const long asn_VAL_36_optional = 0;
 384 static const asn_ioc_cell_t asn_IOS_RICcontrolRequest_IEs_1_rows[] = {
 385         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_31_id_RICrequestID },
 386         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_31_reject },
 387         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 388         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_31_mandatory },
 389         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_32_id_RANfunctionID },
 390         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_32_reject },
 391         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 392         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_32_mandatory },
 393         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_33_id_RICcallProcessID },
 394         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_33_reject },
 395         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 396         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_33_optional },
 397         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_34_id_RICcontrolHeader },
 398         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_34_reject },
 399         { "&Value", aioc__type, &asn_DEF_RICcontrolHeader },
 400         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_34_mandatory },
 401         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_35_id_RICcontrolMessage },
 402         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_35_reject },
 403         { "&Value", aioc__type, &asn_DEF_RICcontrolMessage },
 404         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_35_mandatory },
 405         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_36_id_RICcontrolAckRequest },
 406         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_36_reject },
 407         { "&Value", aioc__type, &asn_DEF_RICcontrolAckRequest },
 408         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_36_optional }
 409 };
 410 static const asn_ioc_set_t asn_IOS_RICcontrolRequest_IEs_1[] = {
 411         { 6, 4, asn_IOS_RICcontrolRequest_IEs_1_rows }
 412 };
 413 static const long asn_VAL_37_id_RICrequestID = 29;
 414 static const long asn_VAL_37_reject = 0;
 415 static const long asn_VAL_37_mandatory = 2;
 416 static const long asn_VAL_38_id_RANfunctionID = 5;
 417 static const long asn_VAL_38_reject = 0;
 418 static const long asn_VAL_38_mandatory = 2;
 419 static const long asn_VAL_39_id_RICcallProcessID = 20;
 420 static const long asn_VAL_39_reject = 0;
 421 static const long asn_VAL_39_optional = 0;
 422 static const long asn_VAL_40_id_RICcontrolStatus = 24;
 423 static const long asn_VAL_40_reject = 0;
 424 static const long asn_VAL_40_mandatory = 2;
 425 static const long asn_VAL_41_id_RICcontrolOutcome = 32;
 426 static const long asn_VAL_41_reject = 0;
 427 static const long asn_VAL_41_optional = 0;
 428 static const asn_ioc_cell_t asn_IOS_RICcontrolAcknowledge_IEs_1_rows[] = {
 429         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_37_id_RICrequestID },
 430         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_37_reject },
 431         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 432         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_37_mandatory },
 433         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_38_id_RANfunctionID },
 434         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_38_reject },
 435         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 436         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_38_mandatory },
 437         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_39_id_RICcallProcessID },
 438         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_39_reject },
 439         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 440         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_39_optional },
 441         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_40_id_RICcontrolStatus },
 442         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_40_reject },
 443         { "&Value", aioc__type, &asn_DEF_RICcontrolStatus },
 444         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_40_mandatory },
 445         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_41_id_RICcontrolOutcome },
 446         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_41_reject },
 447         { "&Value", aioc__type, &asn_DEF_RICcontrolOutcome },
 448         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_41_optional }
 449 };
 450 static const asn_ioc_set_t asn_IOS_RICcontrolAcknowledge_IEs_1[] = {
 451         { 5, 4, asn_IOS_RICcontrolAcknowledge_IEs_1_rows }
 452 };
 453 static const long asn_VAL_42_id_RICrequestID = 29;
 454 static const long asn_VAL_42_reject = 0;
 455 static const long asn_VAL_42_mandatory = 2;
 456 static const long asn_VAL_43_id_RANfunctionID = 5;
 457 static const long asn_VAL_43_reject = 0;
 458 static const long asn_VAL_43_mandatory = 2;
 459 static const long asn_VAL_44_id_RICcallProcessID = 20;
 460 static const long asn_VAL_44_reject = 0;
 461 static const long asn_VAL_44_optional = 0;
 462 static const long asn_VAL_45_id_Cause = 1;
 463 static const long asn_VAL_45_ignore = 1;
 464 static const long asn_VAL_45_mandatory = 2;
 465 static const long asn_VAL_46_id_RICcontrolOutcome = 32;
 466 static const long asn_VAL_46_reject = 0;
 467 static const long asn_VAL_46_optional = 0;
 468 static const asn_ioc_cell_t asn_IOS_RICcontrolFailure_IEs_1_rows[] = {
 469         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_42_id_RICrequestID },
 470         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_42_reject },
 471         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 472         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_42_mandatory },
 473         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_43_id_RANfunctionID },
 474         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_43_reject },
 475         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 476         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_43_mandatory },
 477         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_44_id_RICcallProcessID },
 478         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_44_reject },
 479         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 480         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_44_optional },
 481         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_45_id_Cause },
 482         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_45_ignore },
 483         { "&Value", aioc__type, &asn_DEF_Cause },
 484         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_45_mandatory },
 485         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_46_id_RICcontrolOutcome },
 486         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_46_reject },
 487         { "&Value", aioc__type, &asn_DEF_RICcontrolOutcome },
 488         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_46_optional }
 489 };
 490 static const asn_ioc_set_t asn_IOS_RICcontrolFailure_IEs_1[] = {
 491         { 5, 4, asn_IOS_RICcontrolFailure_IEs_1_rows }
 492 };
 493 static const long asn_VAL_47_id_RICrequestID = 29;
 494 static const long asn_VAL_47_reject = 0;
 495 static const long asn_VAL_47_optional = 0;
 496 static const long asn_VAL_48_id_RANfunctionID = 5;
 497 static const long asn_VAL_48_reject = 0;
 498 static const long asn_VAL_48_optional = 0;
 499 static const long asn_VAL_49_id_Cause = 1;
 500 static const long asn_VAL_49_ignore = 1;
 501 static const long asn_VAL_49_optional = 0;
 502 static const long asn_VAL_50_id_CriticalityDiagnostics = 2;
 503 static const long asn_VAL_50_ignore = 1;
 504 static const long asn_VAL_50_optional = 0;
 505 static const asn_ioc_cell_t asn_IOS_ErrorIndication_IEs_1_rows[] = {
 506         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_47_id_RICrequestID },
 507         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_47_reject },
 508         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 509         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_47_optional },
 510         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_48_id_RANfunctionID },
 511         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_48_reject },
 512         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 513         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_48_optional },
 514         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_49_id_Cause },
 515         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_49_ignore },
 516         { "&Value", aioc__type, &asn_DEF_Cause },
 517         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_49_optional },
 518         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_50_id_CriticalityDiagnostics },
 519         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_50_ignore },
 520         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 521         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_50_optional }
 522 };
 523 static const asn_ioc_set_t asn_IOS_ErrorIndication_IEs_1[] = {
 524         { 4, 4, asn_IOS_ErrorIndication_IEs_1_rows }
 525 };
 526 static const long asn_VAL_51_id_GlobalE2node_ID = 3;
 527 static const long asn_VAL_51_reject = 0;
 528 static const long asn_VAL_51_mandatory = 2;
 529 static const long asn_VAL_52_id_RANfunctionsAdded = 10;
 530 static const long asn_VAL_52_reject = 0;
 531 static const long asn_VAL_52_optional = 0;
 532 static const long asn_VAL_53_id_E2nodeComponentConfigUpdate = 33;
 533 static const long asn_VAL_53_reject = 0;
 534 static const long asn_VAL_53_optional = 0;
 535 static const asn_ioc_cell_t asn_IOS_E2setupRequestIEs_1_rows[] = {
 536         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_51_id_GlobalE2node_ID },
 537         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_51_reject },
 538         { "&Value", aioc__type, &asn_DEF_GlobalE2node_ID },
 539         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_51_mandatory },
 540         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_52_id_RANfunctionsAdded },
 541         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_52_reject },
 542         { "&Value", aioc__type, &asn_DEF_RANfunctions_List },
 543         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_52_optional },
 544         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_53_id_E2nodeComponentConfigUpdate },
 545         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_53_reject },
 546         { "&Value", aioc__type, &asn_DEF_E2nodeComponentConfigUpdate_List },
 547         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_53_optional }
 548 };
 549 static const asn_ioc_set_t asn_IOS_E2setupRequestIEs_1[] = {
 550         { 3, 4, asn_IOS_E2setupRequestIEs_1_rows }
 551 };
 552 static const long asn_VAL_54_id_GlobalRIC_ID = 4;
 553 static const long asn_VAL_54_reject = 0;
 554 static const long asn_VAL_54_mandatory = 2;
 555 static const long asn_VAL_55_id_RANfunctionsAccepted = 9;
 556 static const long asn_VAL_55_reject = 0;
 557 static const long asn_VAL_55_optional = 0;
 558 static const long asn_VAL_56_id_RANfunctionsRejected = 13;
 559 static const long asn_VAL_56_reject = 0;
 560 static const long asn_VAL_56_optional = 0;
 561 static const long asn_VAL_57_id_E2nodeComponentConfigUpdateAck = 35;
 562 static const long asn_VAL_57_reject = 0;
 563 static const long asn_VAL_57_optional = 0;
 564 static const asn_ioc_cell_t asn_IOS_E2setupResponseIEs_1_rows[] = {
 565         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_54_id_GlobalRIC_ID },
 566         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_54_reject },
 567         { "&Value", aioc__type, &asn_DEF_GlobalRIC_ID },
 568         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_54_mandatory },
 569         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_55_id_RANfunctionsAccepted },
 570         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_55_reject },
 571         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 572         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_55_optional },
 573         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_56_id_RANfunctionsRejected },
 574         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_56_reject },
 575         { "&Value", aioc__type, &asn_DEF_RANfunctionsIDcause_List },
 576         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_56_optional },
 577         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_57_id_E2nodeComponentConfigUpdateAck },
 578         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_57_reject },
 579         { "&Value", aioc__type, &asn_DEF_E2nodeComponentConfigUpdateAck_List },
 580         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_57_optional }
 581 };
 582 static const asn_ioc_set_t asn_IOS_E2setupResponseIEs_1[] = {
 583         { 4, 4, asn_IOS_E2setupResponseIEs_1_rows }
 584 };
 585 static const long asn_VAL_58_id_Cause = 1;
 586 static const long asn_VAL_58_ignore = 1;
 587 static const long asn_VAL_58_mandatory = 2;
 588 static const long asn_VAL_59_id_TimeToWait = 31;
 589 static const long asn_VAL_59_ignore = 1;
 590 static const long asn_VAL_59_optional = 0;
 591 static const long asn_VAL_60_id_CriticalityDiagnostics = 2;
 592 static const long asn_VAL_60_ignore = 1;
 593 static const long asn_VAL_60_optional = 0;
 594 static const long asn_VAL_61_id_TNLinformation = 48;
 595 static const long asn_VAL_61_ignore = 1;
 596 static const long asn_VAL_61_optional = 0;
 597 static const asn_ioc_cell_t asn_IOS_E2setupFailureIEs_1_rows[] = {
 598         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_58_id_Cause },
 599         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_58_ignore },
 600         { "&Value", aioc__type, &asn_DEF_Cause },
 601         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_58_mandatory },
 602         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_59_id_TimeToWait },
 603         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_59_ignore },
 604         { "&Value", aioc__type, &asn_DEF_TimeToWait },
 605         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_59_optional },
 606         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_60_id_CriticalityDiagnostics },
 607         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_60_ignore },
 608         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 609         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_60_optional },
 610         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_61_id_TNLinformation },
 611         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_61_ignore },
 612         { "&Value", aioc__type, &asn_DEF_TNLinformation },
 613         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_61_optional }
 614 };
 615 static const asn_ioc_set_t asn_IOS_E2setupFailureIEs_1[] = {
 616         { 4, 4, asn_IOS_E2setupFailureIEs_1_rows }
 617 };
 618 static const long asn_VAL_62_id_E2connectionUpdateAdd = 44;
 619 static const long asn_VAL_62_reject = 0;
 620 static const long asn_VAL_62_optional = 0;
 621 static const long asn_VAL_63_id_E2connectionUpdateRemove = 46;
 622 static const long asn_VAL_63_reject = 0;
 623 static const long asn_VAL_63_optional = 0;
 624 static const long asn_VAL_64_id_E2connectionUpdateModify = 45;
 625 static const long asn_VAL_64_reject = 0;
 626 static const long asn_VAL_64_optional = 0;
 627 static const asn_ioc_cell_t asn_IOS_E2connectionUpdate_IEs_1_rows[] = {
 628         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_62_id_E2connectionUpdateAdd },
 629         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_62_reject },
 630         { "&Value", aioc__type, &asn_DEF_E2connectionUpdate_List },
 631         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_62_optional },
 632         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_63_id_E2connectionUpdateRemove },
 633         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_63_reject },
 634         { "&Value", aioc__type, &asn_DEF_E2connectionUpdateRemove_List },
 635         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_63_optional },
 636         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_64_id_E2connectionUpdateModify },
 637         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_64_reject },
 638         { "&Value", aioc__type, &asn_DEF_E2connectionUpdate_List },
 639         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_64_optional }
 640 };
 641 static const asn_ioc_set_t asn_IOS_E2connectionUpdate_IEs_1[] = {
 642         { 3, 4, asn_IOS_E2connectionUpdate_IEs_1_rows }
 643 };
 644 static const long asn_VAL_67_id_E2connectionSetup = 39;
 645 static const long asn_VAL_67_reject = 0;
 646 static const long asn_VAL_67_optional = 0;
 647 static const long asn_VAL_68_id_E2connectionSetupFailed = 40;
 648 static const long asn_VAL_68_reject = 0;
 649 static const long asn_VAL_68_optional = 0;
 650 static const asn_ioc_cell_t asn_IOS_E2connectionUpdateAck_IEs_1_rows[] = {
 651         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_67_id_E2connectionSetup },
 652         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_67_reject },
 653         { "&Value", aioc__type, &asn_DEF_E2connectionUpdate_List },
 654         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_67_optional },
 655         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_68_id_E2connectionSetupFailed },
 656         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_68_reject },
 657         { "&Value", aioc__type, &asn_DEF_E2connectionSetupFailed_List },
 658         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_68_optional }
 659 };
 660 static const asn_ioc_set_t asn_IOS_E2connectionUpdateAck_IEs_1[] = {
 661         { 2, 4, asn_IOS_E2connectionUpdateAck_IEs_1_rows }
 662 };
 663 static const long asn_VAL_70_id_Cause = 1;
 664 static const long asn_VAL_70_reject = 0;
 665 static const long asn_VAL_70_optional = 0;
 666 static const long asn_VAL_71_id_TimeToWait = 31;
 667 static const long asn_VAL_71_ignore = 1;
 668 static const long asn_VAL_71_optional = 0;
 669 static const long asn_VAL_72_id_CriticalityDiagnostics = 2;
 670 static const long asn_VAL_72_ignore = 1;
 671 static const long asn_VAL_72_optional = 0;
 672 static const asn_ioc_cell_t asn_IOS_E2connectionUpdateFailure_IEs_1_rows[] = {
 673         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_70_id_Cause },
 674         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_70_reject },
 675         { "&Value", aioc__type, &asn_DEF_Cause },
 676         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_70_optional },
 677         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_71_id_TimeToWait },
 678         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_71_ignore },
 679         { "&Value", aioc__type, &asn_DEF_TimeToWait },
 680         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_71_optional },
 681         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_72_id_CriticalityDiagnostics },
 682         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_72_ignore },
 683         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 684         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_72_optional }
 685 };
 686 static const asn_ioc_set_t asn_IOS_E2connectionUpdateFailure_IEs_1[] = {
 687         { 3, 4, asn_IOS_E2connectionUpdateFailure_IEs_1_rows }
 688 };
 689 static const long asn_VAL_73_id_E2nodeComponentConfigUpdate = 33;
 690 static const long asn_VAL_73_reject = 0;
 691 static const long asn_VAL_73_optional = 0;
 692 static const asn_ioc_cell_t asn_IOS_E2nodeConfigurationUpdate_IEs_1_rows[] = {
 693         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_73_id_E2nodeComponentConfigUpdate },
 694         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_73_reject },
 695         { "&Value", aioc__type, &asn_DEF_E2nodeComponentConfigUpdate_List },
 696         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_73_optional }
 697 };
 698 static const asn_ioc_set_t asn_IOS_E2nodeConfigurationUpdate_IEs_1[] = {
 699         { 1, 4, asn_IOS_E2nodeConfigurationUpdate_IEs_1_rows }
 700 };
 701 static const long asn_VAL_75_id_E2nodeComponentConfigUpdateAck = 35;
 702 static const long asn_VAL_75_reject = 0;
 703 static const long asn_VAL_75_optional = 0;
 704 static const asn_ioc_cell_t asn_IOS_E2nodeConfigurationUpdateAcknowledge_IEs_1_rows[] = {
 705         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_75_id_E2nodeComponentConfigUpdateAck },
 706         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_75_reject },
 707         { "&Value", aioc__type, &asn_DEF_E2nodeComponentConfigUpdateAck_List },
 708         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_75_optional }
 709 };
 710 static const asn_ioc_set_t asn_IOS_E2nodeConfigurationUpdateAcknowledge_IEs_1[] = {
 711         { 1, 4, asn_IOS_E2nodeConfigurationUpdateAcknowledge_IEs_1_rows }
 712 };
 713 static const long asn_VAL_77_id_Cause = 1;
 714 static const long asn_VAL_77_ignore = 1;
 715 static const long asn_VAL_77_mandatory = 2;
 716 static const long asn_VAL_78_id_TimeToWait = 31;
 717 static const long asn_VAL_78_ignore = 1;
 718 static const long asn_VAL_78_optional = 0;
 719 static const long asn_VAL_79_id_CriticalityDiagnostics = 2;
 720 static const long asn_VAL_79_ignore = 1;
 721 static const long asn_VAL_79_optional = 0;
 722 static const asn_ioc_cell_t asn_IOS_E2nodeConfigurationUpdateFailure_IEs_1_rows[] = {
 723         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_77_id_Cause },
 724         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_77_ignore },
 725         { "&Value", aioc__type, &asn_DEF_Cause },
 726         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_77_mandatory },
 727         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_78_id_TimeToWait },
 728         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_78_ignore },
 729         { "&Value", aioc__type, &asn_DEF_TimeToWait },
 730         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_78_optional },
 731         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_79_id_CriticalityDiagnostics },
 732         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_79_ignore },
 733         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 734         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_79_optional }
 735 };
 736 static const asn_ioc_set_t asn_IOS_E2nodeConfigurationUpdateFailure_IEs_1[] = {
 737         { 3, 4, asn_IOS_E2nodeConfigurationUpdateFailure_IEs_1_rows }
 738 };
 739 static const long asn_VAL_80_id_Cause = 1;
 740 static const long asn_VAL_80_ignore = 1;
 741 static const long asn_VAL_80_mandatory = 2;
 742 static const asn_ioc_cell_t asn_IOS_ResetRequestIEs_1_rows[] = {
 743         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_80_id_Cause },
 744         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_80_ignore },
 745         { "&Value", aioc__type, &asn_DEF_Cause },
 746         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_80_mandatory }
 747 };
 748 static const asn_ioc_set_t asn_IOS_ResetRequestIEs_1[] = {
 749         { 1, 4, asn_IOS_ResetRequestIEs_1_rows }
 750 };
 751 static const long asn_VAL_81_id_CriticalityDiagnostics = 2;
 752 static const long asn_VAL_81_ignore = 1;
 753 static const long asn_VAL_81_optional = 0;
 754 static const asn_ioc_cell_t asn_IOS_ResetResponseIEs_1_rows[] = {
 755         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_81_id_CriticalityDiagnostics },
 756         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_81_ignore },
 757         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 758         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_81_optional }
 759 };
 760 static const asn_ioc_set_t asn_IOS_ResetResponseIEs_1[] = {
 761         { 1, 4, asn_IOS_ResetResponseIEs_1_rows }
 762 };
 763 static const long asn_VAL_82_id_RANfunctionsAdded = 10;
 764 static const long asn_VAL_82_reject = 0;
 765 static const long asn_VAL_82_optional = 0;
 766 static const long asn_VAL_83_id_RANfunctionsModified = 12;
 767 static const long asn_VAL_83_reject = 0;
 768 static const long asn_VAL_83_optional = 0;
 769 static const long asn_VAL_84_id_RANfunctionsDeleted = 11;
 770 static const long asn_VAL_84_reject = 0;
 771 static const long asn_VAL_84_optional = 0;
 772 static const asn_ioc_cell_t asn_IOS_RICserviceUpdate_IEs_1_rows[] = {
 773         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_82_id_RANfunctionsAdded },
 774         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_82_reject },
 775         { "&Value", aioc__type, &asn_DEF_RANfunctions_List },
 776         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_82_optional },
 777         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_83_id_RANfunctionsModified },
 778         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_83_reject },
 779         { "&Value", aioc__type, &asn_DEF_RANfunctions_List },
 780         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_83_optional },
 781         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_84_id_RANfunctionsDeleted },
 782         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_84_reject },
 783         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 784         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_84_optional }
 785 };
 786 static const asn_ioc_set_t asn_IOS_RICserviceUpdate_IEs_1[] = {
 787         { 3, 4, asn_IOS_RICserviceUpdate_IEs_1_rows }
 788 };
 789 static const long asn_VAL_87_id_RANfunctionsAccepted = 9;
 790 static const long asn_VAL_87_reject = 0;
 791 static const long asn_VAL_87_optional = 0;
 792 static const long asn_VAL_88_id_RANfunctionsRejected = 13;
 793 static const long asn_VAL_88_reject = 0;
 794 static const long asn_VAL_88_optional = 0;
 795 static const asn_ioc_cell_t asn_IOS_RICserviceUpdateAcknowledge_IEs_1_rows[] = {
 796         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_87_id_RANfunctionsAccepted },
 797         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_87_reject },
 798         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 799         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_87_optional },
 800         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_88_id_RANfunctionsRejected },
 801         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_88_reject },
 802         { "&Value", aioc__type, &asn_DEF_RANfunctionsIDcause_List },
 803         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_88_optional }
 804 };
 805 static const asn_ioc_set_t asn_IOS_RICserviceUpdateAcknowledge_IEs_1[] = {
 806         { 2, 4, asn_IOS_RICserviceUpdateAcknowledge_IEs_1_rows }
 807 };
 808 static const long asn_VAL_90_id_RANfunctionsRejected = 13;
 809 static const long asn_VAL_90_ignore = 1;
 810 static const long asn_VAL_90_optional = 0;
 811 static const long asn_VAL_91_id_TimeToWait = 31;
 812 static const long asn_VAL_91_ignore = 1;
 813 static const long asn_VAL_91_optional = 0;
 814 static const long asn_VAL_92_id_CriticalityDiagnostics = 2;
 815 static const long asn_VAL_92_ignore = 1;
 816 static const long asn_VAL_92_optional = 0;
 817 static const asn_ioc_cell_t asn_IOS_RICserviceUpdateFailure_IEs_1_rows[] = {
 818         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_90_id_RANfunctionsRejected },
 819         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_90_ignore },
 820         { "&Value", aioc__type, &asn_DEF_RANfunctionsIDcause_List },
 821         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_90_optional },
 822         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_91_id_TimeToWait },
 823         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_91_ignore },
 824         { "&Value", aioc__type, &asn_DEF_TimeToWait },
 825         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_91_optional },
 826         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_92_id_CriticalityDiagnostics },
 827         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_92_ignore },
 828         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 829         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_92_optional }
 830 };
 831 static const asn_ioc_set_t asn_IOS_RICserviceUpdateFailure_IEs_1[] = {
 832         { 3, 4, asn_IOS_RICserviceUpdateFailure_IEs_1_rows }
 833 };
 834 static const long asn_VAL_93_id_RANfunctionsAccepted = 9;
 835 static const long asn_VAL_93_reject = 0;
 836 static const long asn_VAL_93_optional = 0;
 837 static const asn_ioc_cell_t asn_IOS_RICserviceQuery_IEs_1_rows[] = {
 838         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_93_id_RANfunctionsAccepted },
 839         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_93_reject },
 840         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 841         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_93_optional }
 842 };
 843 static const asn_ioc_set_t asn_IOS_RICserviceQuery_IEs_1[] = {
 844         { 1, 4, asn_IOS_RICserviceQuery_IEs_1_rows }
 845 };
 846 static int
 847 memb_id_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 848                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 849         long value;
 850
 851         if(!sptr) {
 852                 ASN__CTFAIL(app_key, td, sptr,
 853                         "%s: value not given (%s:%d)",
 854                         td->name, __FILE__, __LINE__);
 855                 return -1;
 856         }
 857
 858         value = *(const long *)sptr;
 859
 860         if((value >= 0 && value <= 65535)) {
 861                 /* Constraint check succeeded */
 862                 return 0;
 863         } else {
 864                 ASN__CTFAIL(app_key, td, sptr,
 865                         "%s: constraint failed (%s:%d)",
 866                         td->name, __FILE__, __LINE__);
 867                 return -1;
 868         }
 869 }
 870
 871 static asn_type_selector_result_t
 872 select_RICaction_ToBeSetup_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 873         asn_type_selector_result_t result = {0, 0};
 874         const asn_ioc_set_t *itable = asn_IOS_RICaction_ToBeSetup_ItemIEs_1;
 875         size_t constraining_column = 0; /* &id */
 876         size_t for_column = 1; /* &criticality */
 877         size_t row, presence_index = 0;
 878         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_ToBeSetup_ItemIEs, id));
 879
 880         for(row=0; row < itable->rows_count; row++) {
 881             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 882             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 883
 884             if(type_cell->cell_kind == aioc__undefined)
 885                 continue;
 886
 887             presence_index++;
 888             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 889                 result.type_descriptor = type_cell->type_descriptor;
 890                 result.presence_index = presence_index;
 891                 break;
 892             }
 893         }
 894
 895         return result;
 896 }
 897
 898 static int
 899 memb_criticality_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 900                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 901
 902         if(!sptr) {
 903                 ASN__CTFAIL(app_key, td, sptr,
 904                         "%s: value not given (%s:%d)",
 905                         td->name, __FILE__, __LINE__);
 906                 return -1;
 907         }
 908
 909
 910         if(1 /* No applicable constraints whatsoever */) {
 911                 /* Nothing is here. See below */
 912         }
 913
 914         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 915 }
 916
 917 static asn_type_selector_result_t
 918 select_RICaction_ToBeSetup_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 919         asn_type_selector_result_t result = {0, 0};
 920         const asn_ioc_set_t *itable = asn_IOS_RICaction_ToBeSetup_ItemIEs_1;
 921         size_t constraining_column = 0; /* &id */
 922         size_t for_column = 2; /* &Value */
 923         size_t row, presence_index = 0;
 924         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_ToBeSetup_ItemIEs, id));
 925
 926         for(row=0; row < itable->rows_count; row++) {
 927             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 928             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 929
 930             if(type_cell->cell_kind == aioc__undefined)
 931                 continue;
 932
 933             presence_index++;
 934             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 935                 result.type_descriptor = type_cell->type_descriptor;
 936                 result.presence_index = presence_index;
 937                 break;
 938             }
 939         }
 940
 941         return result;
 942 }
 943
 944 static int
 945 memb_value_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 946                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 947
 948         if(!sptr) {
 949                 ASN__CTFAIL(app_key, td, sptr,
 950                         "%s: value not given (%s:%d)",
 951                         td->name, __FILE__, __LINE__);
 952                 return -1;
 953         }
 954
 955
 956         if(1 /* No applicable constraints whatsoever */) {
 957                 /* Nothing is here. See below */
 958         }
 959
 960         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 961 }
 962
 963 static int
 964 memb_id_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 965                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 966         long value;
 967
 968         if(!sptr) {
 969                 ASN__CTFAIL(app_key, td, sptr,
 970                         "%s: value not given (%s:%d)",
 971                         td->name, __FILE__, __LINE__);
 972                 return -1;
 973         }
 974
 975         value = *(const long *)sptr;
 976
 977         if((value >= 0 && value <= 65535)) {
 978                 /* Constraint check succeeded */
 979                 return 0;
 980         } else {
 981                 ASN__CTFAIL(app_key, td, sptr,
 982                         "%s: constraint failed (%s:%d)",
 983                         td->name, __FILE__, __LINE__);
 984                 return -1;
 985         }
 986 }
 987
 988 static asn_type_selector_result_t
 989 select_RICaction_Admitted_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 990         asn_type_selector_result_t result = {0, 0};
 991         const asn_ioc_set_t *itable = asn_IOS_RICaction_Admitted_ItemIEs_1;
 992         size_t constraining_column = 0; /* &id */
 993         size_t for_column = 1; /* &criticality */
 994         size_t row, presence_index = 0;
 995         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_Admitted_ItemIEs, id));
 996
 997         for(row=0; row < itable->rows_count; row++) {
 998             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 999             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1000
1001             if(type_cell->cell_kind == aioc__undefined)
1002                 continue;
1003
1004             presence_index++;
1005             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1006                 result.type_descriptor = type_cell->type_descriptor;
1007                 result.presence_index = presence_index;
1008                 break;
1009             }
1010         }
1011
1012         return result;
1013 }
1014
1015 static int
1016 memb_criticality_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
1017                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1018
1019         if(!sptr) {
1020                 ASN__CTFAIL(app_key, td, sptr,
1021                         "%s: value not given (%s:%d)",
1022                         td->name, __FILE__, __LINE__);
1023                 return -1;
1024         }
1025
1026
1027         if(1 /* No applicable constraints whatsoever */) {
1028                 /* Nothing is here. See below */
1029         }
1030
1031         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1032 }
1033
1034 static asn_type_selector_result_t
1035 select_RICaction_Admitted_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1036         asn_type_selector_result_t result = {0, 0};
1037         const asn_ioc_set_t *itable = asn_IOS_RICaction_Admitted_ItemIEs_1;
1038         size_t constraining_column = 0; /* &id */
1039         size_t for_column = 2; /* &Value */
1040         size_t row, presence_index = 0;
1041         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_Admitted_ItemIEs, id));
1042
1043         for(row=0; row < itable->rows_count; row++) {
1044             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1045             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1046
1047             if(type_cell->cell_kind == aioc__undefined)
1048                 continue;
1049
1050             presence_index++;
1051             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1052                 result.type_descriptor = type_cell->type_descriptor;
1053                 result.presence_index = presence_index;
1054                 break;
1055             }
1056         }
1057
1058         return result;
1059 }
1060
1061 static int
1062 memb_value_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
1063                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1064
1065         if(!sptr) {
1066                 ASN__CTFAIL(app_key, td, sptr,
1067                         "%s: value not given (%s:%d)",
1068                         td->name, __FILE__, __LINE__);
1069                 return -1;
1070         }
1071
1072
1073         if(1 /* No applicable constraints whatsoever */) {
1074                 /* Nothing is here. See below */
1075         }
1076
1077         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1078 }
1079
1080 static int
1081 memb_id_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
1082                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1083         long value;
1084
1085         if(!sptr) {
1086                 ASN__CTFAIL(app_key, td, sptr,
1087                         "%s: value not given (%s:%d)",
1088                         td->name, __FILE__, __LINE__);
1089                 return -1;
1090         }
1091
1092         value = *(const long *)sptr;
1093
1094         if((value >= 0 && value <= 65535)) {
1095                 /* Constraint check succeeded */
1096                 return 0;
1097         } else {
1098                 ASN__CTFAIL(app_key, td, sptr,
1099                         "%s: constraint failed (%s:%d)",
1100                         td->name, __FILE__, __LINE__);
1101                 return -1;
1102         }
1103 }
1104
1105 static asn_type_selector_result_t
1106 select_RICaction_NotAdmitted_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1107         asn_type_selector_result_t result = {0, 0};
1108         const asn_ioc_set_t *itable = asn_IOS_RICaction_NotAdmitted_ItemIEs_1;
1109         size_t constraining_column = 0; /* &id */
1110         size_t for_column = 1; /* &criticality */
1111         size_t row, presence_index = 0;
1112         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_NotAdmitted_ItemIEs, id));
1113
1114         for(row=0; row < itable->rows_count; row++) {
1115             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1116             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1117
1118             if(type_cell->cell_kind == aioc__undefined)
1119                 continue;
1120
1121             presence_index++;
1122             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1123                 result.type_descriptor = type_cell->type_descriptor;
1124                 result.presence_index = presence_index;
1125                 break;
1126             }
1127         }
1128
1129         return result;
1130 }
1131
1132 static int
1133 memb_criticality_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
1134                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1135
1136         if(!sptr) {
1137                 ASN__CTFAIL(app_key, td, sptr,
1138                         "%s: value not given (%s:%d)",
1139                         td->name, __FILE__, __LINE__);
1140                 return -1;
1141         }
1142
1143
1144         if(1 /* No applicable constraints whatsoever */) {
1145                 /* Nothing is here. See below */
1146         }
1147
1148         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1149 }
1150
1151 static asn_type_selector_result_t
1152 select_RICaction_NotAdmitted_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1153         asn_type_selector_result_t result = {0, 0};
1154         const asn_ioc_set_t *itable = asn_IOS_RICaction_NotAdmitted_ItemIEs_1;
1155         size_t constraining_column = 0; /* &id */
1156         size_t for_column = 2; /* &Value */
1157         size_t row, presence_index = 0;
1158         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_NotAdmitted_ItemIEs, id));
1159
1160         for(row=0; row < itable->rows_count; row++) {
1161             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1162             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1163
1164             if(type_cell->cell_kind == aioc__undefined)
1165                 continue;
1166
1167             presence_index++;
1168             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1169                 result.type_descriptor = type_cell->type_descriptor;
1170                 result.presence_index = presence_index;
1171                 break;
1172             }
1173         }
1174
1175         return result;
1176 }
1177
1178 static int
1179 memb_value_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
1180                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1181
1182         if(!sptr) {
1183                 ASN__CTFAIL(app_key, td, sptr,
1184                         "%s: value not given (%s:%d)",
1185                         td->name, __FILE__, __LINE__);
1186                 return -1;
1187         }
1188
1189
1190         if(1 /* No applicable constraints whatsoever */) {
1191                 /* Nothing is here. See below */
1192         }
1193
1194         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1195 }
1196
1197 static int
1198 memb_id_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
1199                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1200         long value;
1201
1202         if(!sptr) {
1203                 ASN__CTFAIL(app_key, td, sptr,
1204                         "%s: value not given (%s:%d)",
1205                         td->name, __FILE__, __LINE__);
1206                 return -1;
1207         }
1208
1209         value = *(const long *)sptr;
1210
1211         if((value >= 0 && value <= 65535)) {
1212                 /* Constraint check succeeded */
1213                 return 0;
1214         } else {
1215                 ASN__CTFAIL(app_key, td, sptr,
1216                         "%s: constraint failed (%s:%d)",
1217                         td->name, __FILE__, __LINE__);
1218                 return -1;
1219         }
1220 }
1221
1222 static asn_type_selector_result_t
1223 select_E2connectionUpdate_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1224         asn_type_selector_result_t result = {0, 0};
1225         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdate_ItemIEs_1;
1226         size_t constraining_column = 0; /* &id */
1227         size_t for_column = 1; /* &criticality */
1228         size_t row, presence_index = 0;
1229         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdate_ItemIEs, id));
1230
1231         for(row=0; row < itable->rows_count; row++) {
1232             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1233             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1234
1235             if(type_cell->cell_kind == aioc__undefined)
1236                 continue;
1237
1238             presence_index++;
1239             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1240                 result.type_descriptor = type_cell->type_descriptor;
1241                 result.presence_index = presence_index;
1242                 break;
1243             }
1244         }
1245
1246         return result;
1247 }
1248
1249 static int
1250 memb_criticality_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
1251                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1252
1253         if(!sptr) {
1254                 ASN__CTFAIL(app_key, td, sptr,
1255                         "%s: value not given (%s:%d)",
1256                         td->name, __FILE__, __LINE__);
1257                 return -1;
1258         }
1259
1260
1261         if(1 /* No applicable constraints whatsoever */) {
1262                 /* Nothing is here. See below */
1263         }
1264
1265         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1266 }
1267
1268 static asn_type_selector_result_t
1269 select_E2connectionUpdate_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1270         asn_type_selector_result_t result = {0, 0};
1271         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdate_ItemIEs_1;
1272         size_t constraining_column = 0; /* &id */
1273         size_t for_column = 2; /* &Value */
1274         size_t row, presence_index = 0;
1275         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdate_ItemIEs, id));
1276
1277         for(row=0; row < itable->rows_count; row++) {
1278             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1279             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1280
1281             if(type_cell->cell_kind == aioc__undefined)
1282                 continue;
1283
1284             presence_index++;
1285             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1286                 result.type_descriptor = type_cell->type_descriptor;
1287                 result.presence_index = presence_index;
1288                 break;
1289             }
1290         }
1291
1292         return result;
1293 }
1294
1295 static int
1296 memb_value_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
1297                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1298
1299         if(!sptr) {
1300                 ASN__CTFAIL(app_key, td, sptr,
1301                         "%s: value not given (%s:%d)",
1302                         td->name, __FILE__, __LINE__);
1303                 return -1;
1304         }
1305
1306
1307         if(1 /* No applicable constraints whatsoever */) {
1308                 /* Nothing is here. See below */
1309         }
1310
1311         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1312 }
1313
1314 static int
1315 memb_id_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1316                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1317         long value;
1318
1319         if(!sptr) {
1320                 ASN__CTFAIL(app_key, td, sptr,
1321                         "%s: value not given (%s:%d)",
1322                         td->name, __FILE__, __LINE__);
1323                 return -1;
1324         }
1325
1326         value = *(const long *)sptr;
1327
1328         if((value >= 0 && value <= 65535)) {
1329                 /* Constraint check succeeded */
1330                 return 0;
1331         } else {
1332                 ASN__CTFAIL(app_key, td, sptr,
1333                         "%s: constraint failed (%s:%d)",
1334                         td->name, __FILE__, __LINE__);
1335                 return -1;
1336         }
1337 }
1338
1339 static asn_type_selector_result_t
1340 select_E2connectionUpdateRemove_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1341         asn_type_selector_result_t result = {0, 0};
1342         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdateRemove_ItemIEs_1;
1343         size_t constraining_column = 0; /* &id */
1344         size_t for_column = 1; /* &criticality */
1345         size_t row, presence_index = 0;
1346         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdateRemove_ItemIEs, id));
1347
1348         for(row=0; row < itable->rows_count; row++) {
1349             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1350             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1351
1352             if(type_cell->cell_kind == aioc__undefined)
1353                 continue;
1354
1355             presence_index++;
1356             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1357                 result.type_descriptor = type_cell->type_descriptor;
1358                 result.presence_index = presence_index;
1359                 break;
1360             }
1361         }
1362
1363         return result;
1364 }
1365
1366 static int
1367 memb_criticality_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1368                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1369
1370         if(!sptr) {
1371                 ASN__CTFAIL(app_key, td, sptr,
1372                         "%s: value not given (%s:%d)",
1373                         td->name, __FILE__, __LINE__);
1374                 return -1;
1375         }
1376
1377
1378         if(1 /* No applicable constraints whatsoever */) {
1379                 /* Nothing is here. See below */
1380         }
1381
1382         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1383 }
1384
1385 static asn_type_selector_result_t
1386 select_E2connectionUpdateRemove_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1387         asn_type_selector_result_t result = {0, 0};
1388         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdateRemove_ItemIEs_1;
1389         size_t constraining_column = 0; /* &id */
1390         size_t for_column = 2; /* &Value */
1391         size_t row, presence_index = 0;
1392         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdateRemove_ItemIEs, id));
1393
1394         for(row=0; row < itable->rows_count; row++) {
1395             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1396             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1397
1398             if(type_cell->cell_kind == aioc__undefined)
1399                 continue;
1400
1401             presence_index++;
1402             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1403                 result.type_descriptor = type_cell->type_descriptor;
1404                 result.presence_index = presence_index;
1405                 break;
1406             }
1407         }
1408
1409         return result;
1410 }
1411
1412 static int
1413 memb_value_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1414                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1415
1416         if(!sptr) {
1417                 ASN__CTFAIL(app_key, td, sptr,
1418                         "%s: value not given (%s:%d)",
1419                         td->name, __FILE__, __LINE__);
1420                 return -1;
1421         }
1422
1423
1424         if(1 /* No applicable constraints whatsoever */) {
1425                 /* Nothing is here. See below */
1426         }
1427
1428         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1429 }
1430
1431 static int
1432 memb_id_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1433                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1434         long value;
1435
1436         if(!sptr) {
1437                 ASN__CTFAIL(app_key, td, sptr,
1438                         "%s: value not given (%s:%d)",
1439                         td->name, __FILE__, __LINE__);
1440                 return -1;
1441         }
1442
1443         value = *(const long *)sptr;
1444
1445         if((value >= 0 && value <= 65535)) {
1446                 /* Constraint check succeeded */
1447                 return 0;
1448         } else {
1449                 ASN__CTFAIL(app_key, td, sptr,
1450                         "%s: constraint failed (%s:%d)",
1451                         td->name, __FILE__, __LINE__);
1452                 return -1;
1453         }
1454 }
1455
1456 static asn_type_selector_result_t
1457 select_E2connectionSetupFailed_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1458         asn_type_selector_result_t result = {0, 0};
1459         const asn_ioc_set_t *itable = asn_IOS_E2connectionSetupFailed_ItemIEs_1;
1460         size_t constraining_column = 0; /* &id */
1461         size_t for_column = 1; /* &criticality */
1462         size_t row, presence_index = 0;
1463         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionSetupFailed_ItemIEs, id));
1464
1465         for(row=0; row < itable->rows_count; row++) {
1466             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1467             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1468
1469             if(type_cell->cell_kind == aioc__undefined)
1470                 continue;
1471
1472             presence_index++;
1473             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1474                 result.type_descriptor = type_cell->type_descriptor;
1475                 result.presence_index = presence_index;
1476                 break;
1477             }
1478         }
1479
1480         return result;
1481 }
1482
1483 static int
1484 memb_criticality_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1485                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1486
1487         if(!sptr) {
1488                 ASN__CTFAIL(app_key, td, sptr,
1489                         "%s: value not given (%s:%d)",
1490                         td->name, __FILE__, __LINE__);
1491                 return -1;
1492         }
1493
1494
1495         if(1 /* No applicable constraints whatsoever */) {
1496                 /* Nothing is here. See below */
1497         }
1498
1499         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1500 }
1501
1502 static asn_type_selector_result_t
1503 select_E2connectionSetupFailed_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1504         asn_type_selector_result_t result = {0, 0};
1505         const asn_ioc_set_t *itable = asn_IOS_E2connectionSetupFailed_ItemIEs_1;
1506         size_t constraining_column = 0; /* &id */
1507         size_t for_column = 2; /* &Value */
1508         size_t row, presence_index = 0;
1509         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionSetupFailed_ItemIEs, id));
1510
1511         for(row=0; row < itable->rows_count; row++) {
1512             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1513             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1514
1515             if(type_cell->cell_kind == aioc__undefined)
1516                 continue;
1517
1518             presence_index++;
1519             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1520                 result.type_descriptor = type_cell->type_descriptor;
1521                 result.presence_index = presence_index;
1522                 break;
1523             }
1524         }
1525
1526         return result;
1527 }
1528
1529 static int
1530 memb_value_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1531                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1532
1533         if(!sptr) {
1534                 ASN__CTFAIL(app_key, td, sptr,
1535                         "%s: value not given (%s:%d)",
1536                         td->name, __FILE__, __LINE__);
1537                 return -1;
1538         }
1539
1540
1541         if(1 /* No applicable constraints whatsoever */) {
1542                 /* Nothing is here. See below */
1543         }
1544
1545         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1546 }
1547
1548 static int
1549 memb_id_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1550                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1551         long value;
1552
1553         if(!sptr) {
1554                 ASN__CTFAIL(app_key, td, sptr,
1555                         "%s: value not given (%s:%d)",
1556                         td->name, __FILE__, __LINE__);
1557                 return -1;
1558         }
1559
1560         value = *(const long *)sptr;
1561
1562         if((value >= 0 && value <= 65535)) {
1563                 /* Constraint check succeeded */
1564                 return 0;
1565         } else {
1566                 ASN__CTFAIL(app_key, td, sptr,
1567                         "%s: constraint failed (%s:%d)",
1568                         td->name, __FILE__, __LINE__);
1569                 return -1;
1570         }
1571 }
1572
1573 static asn_type_selector_result_t
1574 select_E2nodeComponentConfigUpdate_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1575         asn_type_selector_result_t result = {0, 0};
1576         const asn_ioc_set_t *itable = asn_IOS_E2nodeComponentConfigUpdate_ItemIEs_1;
1577         size_t constraining_column = 0; /* &id */
1578         size_t for_column = 1; /* &criticality */
1579         size_t row, presence_index = 0;
1580         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeComponentConfigUpdate_ItemIEs, id));
1581
1582         for(row=0; row < itable->rows_count; row++) {
1583             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1584             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1585
1586             if(type_cell->cell_kind == aioc__undefined)
1587                 continue;
1588
1589             presence_index++;
1590             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1591                 result.type_descriptor = type_cell->type_descriptor;
1592                 result.presence_index = presence_index;
1593                 break;
1594             }
1595         }
1596
1597         return result;
1598 }
1599
1600 static int
1601 memb_criticality_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1602                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1603
1604         if(!sptr) {
1605                 ASN__CTFAIL(app_key, td, sptr,
1606                         "%s: value not given (%s:%d)",
1607                         td->name, __FILE__, __LINE__);
1608                 return -1;
1609         }
1610
1611
1612         if(1 /* No applicable constraints whatsoever */) {
1613                 /* Nothing is here. See below */
1614         }
1615
1616         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1617 }
1618
1619 static asn_type_selector_result_t
1620 select_E2nodeComponentConfigUpdate_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1621         asn_type_selector_result_t result = {0, 0};
1622         const asn_ioc_set_t *itable = asn_IOS_E2nodeComponentConfigUpdate_ItemIEs_1;
1623         size_t constraining_column = 0; /* &id */
1624         size_t for_column = 2; /* &Value */
1625         size_t row, presence_index = 0;
1626         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeComponentConfigUpdate_ItemIEs, id));
1627
1628         for(row=0; row < itable->rows_count; row++) {
1629             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1630             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1631
1632             if(type_cell->cell_kind == aioc__undefined)
1633                 continue;
1634
1635             presence_index++;
1636             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1637                 result.type_descriptor = type_cell->type_descriptor;
1638                 result.presence_index = presence_index;
1639                 break;
1640             }
1641         }
1642
1643         return result;
1644 }
1645
1646 static int
1647 memb_value_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1648                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1649
1650         if(!sptr) {
1651                 ASN__CTFAIL(app_key, td, sptr,
1652                         "%s: value not given (%s:%d)",
1653                         td->name, __FILE__, __LINE__);
1654                 return -1;
1655         }
1656
1657
1658         if(1 /* No applicable constraints whatsoever */) {
1659                 /* Nothing is here. See below */
1660         }
1661
1662         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1663 }
1664
1665 static int
1666 memb_id_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1667                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1668         long value;
1669
1670         if(!sptr) {
1671                 ASN__CTFAIL(app_key, td, sptr,
1672                         "%s: value not given (%s:%d)",
1673                         td->name, __FILE__, __LINE__);
1674                 return -1;
1675         }
1676
1677         value = *(const long *)sptr;
1678
1679         if((value >= 0 && value <= 65535)) {
1680                 /* Constraint check succeeded */
1681                 return 0;
1682         } else {
1683                 ASN__CTFAIL(app_key, td, sptr,
1684                         "%s: constraint failed (%s:%d)",
1685                         td->name, __FILE__, __LINE__);
1686                 return -1;
1687         }
1688 }
1689
1690 static asn_type_selector_result_t
1691 select_E2nodeComponentConfigUpdateAck_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1692         asn_type_selector_result_t result = {0, 0};
1693         const asn_ioc_set_t *itable = asn_IOS_E2nodeComponentConfigUpdateAck_ItemIEs_1;
1694         size_t constraining_column = 0; /* &id */
1695         size_t for_column = 1; /* &criticality */
1696         size_t row, presence_index = 0;
1697         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs, id));
1698
1699         for(row=0; row < itable->rows_count; row++) {
1700             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1701             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1702
1703             if(type_cell->cell_kind == aioc__undefined)
1704                 continue;
1705
1706             presence_index++;
1707             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1708                 result.type_descriptor = type_cell->type_descriptor;
1709                 result.presence_index = presence_index;
1710                 break;
1711             }
1712         }
1713
1714         return result;
1715 }
1716
1717 static int
1718 memb_criticality_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1719                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1720
1721         if(!sptr) {
1722                 ASN__CTFAIL(app_key, td, sptr,
1723                         "%s: value not given (%s:%d)",
1724                         td->name, __FILE__, __LINE__);
1725                 return -1;
1726         }
1727
1728
1729         if(1 /* No applicable constraints whatsoever */) {
1730                 /* Nothing is here. See below */
1731         }
1732
1733         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1734 }
1735
1736 static asn_type_selector_result_t
1737 select_E2nodeComponentConfigUpdateAck_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1738         asn_type_selector_result_t result = {0, 0};
1739         const asn_ioc_set_t *itable = asn_IOS_E2nodeComponentConfigUpdateAck_ItemIEs_1;
1740         size_t constraining_column = 0; /* &id */
1741         size_t for_column = 2; /* &Value */
1742         size_t row, presence_index = 0;
1743         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs, id));
1744
1745         for(row=0; row < itable->rows_count; row++) {
1746             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1747             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1748
1749             if(type_cell->cell_kind == aioc__undefined)
1750                 continue;
1751
1752             presence_index++;
1753             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1754                 result.type_descriptor = type_cell->type_descriptor;
1755                 result.presence_index = presence_index;
1756                 break;
1757             }
1758         }
1759
1760         return result;
1761 }
1762
1763 static int
1764 memb_value_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1765                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1766
1767         if(!sptr) {
1768                 ASN__CTFAIL(app_key, td, sptr,
1769                         "%s: value not given (%s:%d)",
1770                         td->name, __FILE__, __LINE__);
1771                 return -1;
1772         }
1773
1774
1775         if(1 /* No applicable constraints whatsoever */) {
1776                 /* Nothing is here. See below */
1777         }
1778
1779         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1780 }
1781
1782 static int
1783 memb_id_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1784                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1785         long value;
1786
1787         if(!sptr) {
1788                 ASN__CTFAIL(app_key, td, sptr,
1789                         "%s: value not given (%s:%d)",
1790                         td->name, __FILE__, __LINE__);
1791                 return -1;
1792         }
1793
1794         value = *(const long *)sptr;
1795
1796         if((value >= 0 && value <= 65535)) {
1797                 /* Constraint check succeeded */
1798                 return 0;
1799         } else {
1800                 ASN__CTFAIL(app_key, td, sptr,
1801                         "%s: constraint failed (%s:%d)",
1802                         td->name, __FILE__, __LINE__);
1803                 return -1;
1804         }
1805 }
1806
1807 static asn_type_selector_result_t
1808 select_RANfunction_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1809         asn_type_selector_result_t result = {0, 0};
1810         const asn_ioc_set_t *itable = asn_IOS_RANfunction_ItemIEs_1;
1811         size_t constraining_column = 0; /* &id */
1812         size_t for_column = 1; /* &criticality */
1813         size_t row, presence_index = 0;
1814         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunction_ItemIEs, id));
1815
1816         for(row=0; row < itable->rows_count; row++) {
1817             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1818             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1819
1820             if(type_cell->cell_kind == aioc__undefined)
1821                 continue;
1822
1823             presence_index++;
1824             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1825                 result.type_descriptor = type_cell->type_descriptor;
1826                 result.presence_index = presence_index;
1827                 break;
1828             }
1829         }
1830
1831         return result;
1832 }
1833
1834 static int
1835 memb_criticality_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1836                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1837
1838         if(!sptr) {
1839                 ASN__CTFAIL(app_key, td, sptr,
1840                         "%s: value not given (%s:%d)",
1841                         td->name, __FILE__, __LINE__);
1842                 return -1;
1843         }
1844
1845
1846         if(1 /* No applicable constraints whatsoever */) {
1847                 /* Nothing is here. See below */
1848         }
1849
1850         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1851 }
1852
1853 static asn_type_selector_result_t
1854 select_RANfunction_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1855         asn_type_selector_result_t result = {0, 0};
1856         const asn_ioc_set_t *itable = asn_IOS_RANfunction_ItemIEs_1;
1857         size_t constraining_column = 0; /* &id */
1858         size_t for_column = 2; /* &Value */
1859         size_t row, presence_index = 0;
1860         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunction_ItemIEs, id));
1861
1862         for(row=0; row < itable->rows_count; row++) {
1863             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1864             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1865
1866             if(type_cell->cell_kind == aioc__undefined)
1867                 continue;
1868
1869             presence_index++;
1870             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1871                 result.type_descriptor = type_cell->type_descriptor;
1872                 result.presence_index = presence_index;
1873                 break;
1874             }
1875         }
1876
1877         return result;
1878 }
1879
1880 static int
1881 memb_value_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1882                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1883
1884         if(!sptr) {
1885                 ASN__CTFAIL(app_key, td, sptr,
1886                         "%s: value not given (%s:%d)",
1887                         td->name, __FILE__, __LINE__);
1888                 return -1;
1889         }
1890
1891
1892         if(1 /* No applicable constraints whatsoever */) {
1893                 /* Nothing is here. See below */
1894         }
1895
1896         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1897 }
1898
1899 static int
1900 memb_id_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1901                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1902         long value;
1903
1904         if(!sptr) {
1905                 ASN__CTFAIL(app_key, td, sptr,
1906                         "%s: value not given (%s:%d)",
1907                         td->name, __FILE__, __LINE__);
1908                 return -1;
1909         }
1910
1911         value = *(const long *)sptr;
1912
1913         if((value >= 0 && value <= 65535)) {
1914                 /* Constraint check succeeded */
1915                 return 0;
1916         } else {
1917                 ASN__CTFAIL(app_key, td, sptr,
1918                         "%s: constraint failed (%s:%d)",
1919                         td->name, __FILE__, __LINE__);
1920                 return -1;
1921         }
1922 }
1923
1924 static asn_type_selector_result_t
1925 select_RANfunctionID_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1926         asn_type_selector_result_t result = {0, 0};
1927         const asn_ioc_set_t *itable = asn_IOS_RANfunctionID_ItemIEs_1;
1928         size_t constraining_column = 0; /* &id */
1929         size_t for_column = 1; /* &criticality */
1930         size_t row, presence_index = 0;
1931         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionID_ItemIEs, id));
1932
1933         for(row=0; row < itable->rows_count; row++) {
1934             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1935             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1936
1937             if(type_cell->cell_kind == aioc__undefined)
1938                 continue;
1939
1940             presence_index++;
1941             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1942                 result.type_descriptor = type_cell->type_descriptor;
1943                 result.presence_index = presence_index;
1944                 break;
1945             }
1946         }
1947
1948         return result;
1949 }
1950
1951 static int
1952 memb_criticality_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1953                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1954
1955         if(!sptr) {
1956                 ASN__CTFAIL(app_key, td, sptr,
1957                         "%s: value not given (%s:%d)",
1958                         td->name, __FILE__, __LINE__);
1959                 return -1;
1960         }
1961
1962
1963         if(1 /* No applicable constraints whatsoever */) {
1964                 /* Nothing is here. See below */
1965         }
1966
1967         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1968 }
1969
1970 static asn_type_selector_result_t
1971 select_RANfunctionID_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1972         asn_type_selector_result_t result = {0, 0};
1973         const asn_ioc_set_t *itable = asn_IOS_RANfunctionID_ItemIEs_1;
1974         size_t constraining_column = 0; /* &id */
1975         size_t for_column = 2; /* &Value */
1976         size_t row, presence_index = 0;
1977         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionID_ItemIEs, id));
1978
1979         for(row=0; row < itable->rows_count; row++) {
1980             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1981             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1982
1983             if(type_cell->cell_kind == aioc__undefined)
1984                 continue;
1985
1986             presence_index++;
1987             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1988                 result.type_descriptor = type_cell->type_descriptor;
1989                 result.presence_index = presence_index;
1990                 break;
1991             }
1992         }
1993
1994         return result;
1995 }
1996
1997 static int
1998 memb_value_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1999                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2000
2001         if(!sptr) {
2002                 ASN__CTFAIL(app_key, td, sptr,
2003                         "%s: value not given (%s:%d)",
2004                         td->name, __FILE__, __LINE__);
2005                 return -1;
2006         }
2007
2008
2009         if(1 /* No applicable constraints whatsoever */) {
2010                 /* Nothing is here. See below */
2011         }
2012
2013         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2014 }
2015
2016 static int
2017 memb_id_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
2018                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2019         long value;
2020
2021         if(!sptr) {
2022                 ASN__CTFAIL(app_key, td, sptr,
2023                         "%s: value not given (%s:%d)",
2024                         td->name, __FILE__, __LINE__);
2025                 return -1;
2026         }
2027
2028         value = *(const long *)sptr;
2029
2030         if((value >= 0 && value <= 65535)) {
2031                 /* Constraint check succeeded */
2032                 return 0;
2033         } else {
2034                 ASN__CTFAIL(app_key, td, sptr,
2035                         "%s: constraint failed (%s:%d)",
2036                         td->name, __FILE__, __LINE__);
2037                 return -1;
2038         }
2039 }
2040
2041 static asn_type_selector_result_t
2042 select_RANfunctionIDcause_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2043         asn_type_selector_result_t result = {0, 0};
2044         const asn_ioc_set_t *itable = asn_IOS_RANfunctionIDcause_ItemIEs_1;
2045         size_t constraining_column = 0; /* &id */
2046         size_t for_column = 1; /* &criticality */
2047         size_t row, presence_index = 0;
2048         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionIDcause_ItemIEs, id));
2049
2050         for(row=0; row < itable->rows_count; row++) {
2051             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2052             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2053
2054             if(type_cell->cell_kind == aioc__undefined)
2055                 continue;
2056
2057             presence_index++;
2058             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2059                 result.type_descriptor = type_cell->type_descriptor;
2060                 result.presence_index = presence_index;
2061                 break;
2062             }
2063         }
2064
2065         return result;
2066 }
2067
2068 static int
2069 memb_criticality_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
2070                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2071
2072         if(!sptr) {
2073                 ASN__CTFAIL(app_key, td, sptr,
2074                         "%s: value not given (%s:%d)",
2075                         td->name, __FILE__, __LINE__);
2076                 return -1;
2077         }
2078
2079
2080         if(1 /* No applicable constraints whatsoever */) {
2081                 /* Nothing is here. See below */
2082         }
2083
2084         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2085 }
2086
2087 static asn_type_selector_result_t
2088 select_RANfunctionIDcause_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2089         asn_type_selector_result_t result = {0, 0};
2090         const asn_ioc_set_t *itable = asn_IOS_RANfunctionIDcause_ItemIEs_1;
2091         size_t constraining_column = 0; /* &id */
2092         size_t for_column = 2; /* &Value */
2093         size_t row, presence_index = 0;
2094         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionIDcause_ItemIEs, id));
2095
2096         for(row=0; row < itable->rows_count; row++) {
2097             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2098             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2099
2100             if(type_cell->cell_kind == aioc__undefined)
2101                 continue;
2102
2103             presence_index++;
2104             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2105                 result.type_descriptor = type_cell->type_descriptor;
2106                 result.presence_index = presence_index;
2107                 break;
2108             }
2109         }
2110
2111         return result;
2112 }
2113
2114 static int
2115 memb_value_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
2116                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2117
2118         if(!sptr) {
2119                 ASN__CTFAIL(app_key, td, sptr,
2120                         "%s: value not given (%s:%d)",
2121                         td->name, __FILE__, __LINE__);
2122                 return -1;
2123         }
2124
2125
2126         if(1 /* No applicable constraints whatsoever */) {
2127                 /* Nothing is here. See below */
2128         }
2129
2130         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2131 }
2132
2133 static int
2134 memb_id_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
2135                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2136         long value;
2137
2138         if(!sptr) {
2139                 ASN__CTFAIL(app_key, td, sptr,
2140                         "%s: value not given (%s:%d)",
2141                         td->name, __FILE__, __LINE__);
2142                 return -1;
2143         }
2144
2145         value = *(const long *)sptr;
2146
2147         if((value >= 0 && value <= 65535)) {
2148                 /* Constraint check succeeded */
2149                 return 0;
2150         } else {
2151                 ASN__CTFAIL(app_key, td, sptr,
2152                         "%s: constraint failed (%s:%d)",
2153                         td->name, __FILE__, __LINE__);
2154                 return -1;
2155         }
2156 }
2157
2158 static asn_type_selector_result_t
2159 select_RICsubscriptionRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2160         asn_type_selector_result_t result = {0, 0};
2161         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionRequest_IEs_1;
2162         size_t constraining_column = 0; /* &id */
2163         size_t for_column = 1; /* &criticality */
2164         size_t row, presence_index = 0;
2165         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionRequest_IEs, id));
2166
2167         for(row=0; row < itable->rows_count; row++) {
2168             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2169             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2170
2171             if(type_cell->cell_kind == aioc__undefined)
2172                 continue;
2173
2174             presence_index++;
2175             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2176                 result.type_descriptor = type_cell->type_descriptor;
2177                 result.presence_index = presence_index;
2178                 break;
2179             }
2180         }
2181
2182         return result;
2183 }
2184
2185 static int
2186 memb_criticality_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
2187                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2188
2189         if(!sptr) {
2190                 ASN__CTFAIL(app_key, td, sptr,
2191                         "%s: value not given (%s:%d)",
2192                         td->name, __FILE__, __LINE__);
2193                 return -1;
2194         }
2195
2196
2197         if(1 /* No applicable constraints whatsoever */) {
2198                 /* Nothing is here. See below */
2199         }
2200
2201         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2202 }
2203
2204 static asn_type_selector_result_t
2205 select_RICsubscriptionRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2206         asn_type_selector_result_t result = {0, 0};
2207         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionRequest_IEs_1;
2208         size_t constraining_column = 0; /* &id */
2209         size_t for_column = 2; /* &Value */
2210         size_t row, presence_index = 0;
2211         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionRequest_IEs, id));
2212
2213         for(row=0; row < itable->rows_count; row++) {
2214             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2215             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2216
2217             if(type_cell->cell_kind == aioc__undefined)
2218                 continue;
2219
2220             presence_index++;
2221             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2222                 result.type_descriptor = type_cell->type_descriptor;
2223                 result.presence_index = presence_index;
2224                 break;
2225             }
2226         }
2227
2228         return result;
2229 }
2230
2231 static int
2232 memb_value_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
2233                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2234
2235         if(!sptr) {
2236                 ASN__CTFAIL(app_key, td, sptr,
2237                         "%s: value not given (%s:%d)",
2238                         td->name, __FILE__, __LINE__);
2239                 return -1;
2240         }
2241
2242
2243         if(1 /* No applicable constraints whatsoever */) {
2244                 /* Nothing is here. See below */
2245         }
2246
2247         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2248 }
2249
2250 static int
2251 memb_id_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2252                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2253         long value;
2254
2255         if(!sptr) {
2256                 ASN__CTFAIL(app_key, td, sptr,
2257                         "%s: value not given (%s:%d)",
2258                         td->name, __FILE__, __LINE__);
2259                 return -1;
2260         }
2261
2262         value = *(const long *)sptr;
2263
2264         if((value >= 0 && value <= 65535)) {
2265                 /* Constraint check succeeded */
2266                 return 0;
2267         } else {
2268                 ASN__CTFAIL(app_key, td, sptr,
2269                         "%s: constraint failed (%s:%d)",
2270                         td->name, __FILE__, __LINE__);
2271                 return -1;
2272         }
2273 }
2274
2275 static asn_type_selector_result_t
2276 select_RICsubscriptionResponse_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2277         asn_type_selector_result_t result = {0, 0};
2278         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionResponse_IEs_1;
2279         size_t constraining_column = 0; /* &id */
2280         size_t for_column = 1; /* &criticality */
2281         size_t row, presence_index = 0;
2282         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionResponse_IEs, id));
2283
2284         for(row=0; row < itable->rows_count; row++) {
2285             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2286             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2287
2288             if(type_cell->cell_kind == aioc__undefined)
2289                 continue;
2290
2291             presence_index++;
2292             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2293                 result.type_descriptor = type_cell->type_descriptor;
2294                 result.presence_index = presence_index;
2295                 break;
2296             }
2297         }
2298
2299         return result;
2300 }
2301
2302 static int
2303 memb_criticality_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2304                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2305
2306         if(!sptr) {
2307                 ASN__CTFAIL(app_key, td, sptr,
2308                         "%s: value not given (%s:%d)",
2309                         td->name, __FILE__, __LINE__);
2310                 return -1;
2311         }
2312
2313
2314         if(1 /* No applicable constraints whatsoever */) {
2315                 /* Nothing is here. See below */
2316         }
2317
2318         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2319 }
2320
2321 static asn_type_selector_result_t
2322 select_RICsubscriptionResponse_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2323         asn_type_selector_result_t result = {0, 0};
2324         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionResponse_IEs_1;
2325         size_t constraining_column = 0; /* &id */
2326         size_t for_column = 2; /* &Value */
2327         size_t row, presence_index = 0;
2328         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionResponse_IEs, id));
2329
2330         for(row=0; row < itable->rows_count; row++) {
2331             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2332             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2333
2334             if(type_cell->cell_kind == aioc__undefined)
2335                 continue;
2336
2337             presence_index++;
2338             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2339                 result.type_descriptor = type_cell->type_descriptor;
2340                 result.presence_index = presence_index;
2341                 break;
2342             }
2343         }
2344
2345         return result;
2346 }
2347
2348 static int
2349 memb_value_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2350                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2351
2352         if(!sptr) {
2353                 ASN__CTFAIL(app_key, td, sptr,
2354                         "%s: value not given (%s:%d)",
2355                         td->name, __FILE__, __LINE__);
2356                 return -1;
2357         }
2358
2359
2360         if(1 /* No applicable constraints whatsoever */) {
2361                 /* Nothing is here. See below */
2362         }
2363
2364         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2365 }
2366
2367 static int
2368 memb_id_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2369                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2370         long value;
2371
2372         if(!sptr) {
2373                 ASN__CTFAIL(app_key, td, sptr,
2374                         "%s: value not given (%s:%d)",
2375                         td->name, __FILE__, __LINE__);
2376                 return -1;
2377         }
2378
2379         value = *(const long *)sptr;
2380
2381         if((value >= 0 && value <= 65535)) {
2382                 /* Constraint check succeeded */
2383                 return 0;
2384         } else {
2385                 ASN__CTFAIL(app_key, td, sptr,
2386                         "%s: constraint failed (%s:%d)",
2387                         td->name, __FILE__, __LINE__);
2388                 return -1;
2389         }
2390 }
2391
2392 static asn_type_selector_result_t
2393 select_RICsubscriptionFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2394         asn_type_selector_result_t result = {0, 0};
2395         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionFailure_IEs_1;
2396         size_t constraining_column = 0; /* &id */
2397         size_t for_column = 1; /* &criticality */
2398         size_t row, presence_index = 0;
2399         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionFailure_IEs, id));
2400
2401         for(row=0; row < itable->rows_count; row++) {
2402             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2403             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2404
2405             if(type_cell->cell_kind == aioc__undefined)
2406                 continue;
2407
2408             presence_index++;
2409             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2410                 result.type_descriptor = type_cell->type_descriptor;
2411                 result.presence_index = presence_index;
2412                 break;
2413             }
2414         }
2415
2416         return result;
2417 }
2418
2419 static int
2420 memb_criticality_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2421                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2422
2423         if(!sptr) {
2424                 ASN__CTFAIL(app_key, td, sptr,
2425                         "%s: value not given (%s:%d)",
2426                         td->name, __FILE__, __LINE__);
2427                 return -1;
2428         }
2429
2430
2431         if(1 /* No applicable constraints whatsoever */) {
2432                 /* Nothing is here. See below */
2433         }
2434
2435         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2436 }
2437
2438 static asn_type_selector_result_t
2439 select_RICsubscriptionFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2440         asn_type_selector_result_t result = {0, 0};
2441         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionFailure_IEs_1;
2442         size_t constraining_column = 0; /* &id */
2443         size_t for_column = 2; /* &Value */
2444         size_t row, presence_index = 0;
2445         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionFailure_IEs, id));
2446
2447         for(row=0; row < itable->rows_count; row++) {
2448             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2449             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2450
2451             if(type_cell->cell_kind == aioc__undefined)
2452                 continue;
2453
2454             presence_index++;
2455             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2456                 result.type_descriptor = type_cell->type_descriptor;
2457                 result.presence_index = presence_index;
2458                 break;
2459             }
2460         }
2461
2462         return result;
2463 }
2464
2465 static int
2466 memb_value_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2467                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2468
2469         if(!sptr) {
2470                 ASN__CTFAIL(app_key, td, sptr,
2471                         "%s: value not given (%s:%d)",
2472                         td->name, __FILE__, __LINE__);
2473                 return -1;
2474         }
2475
2476
2477         if(1 /* No applicable constraints whatsoever */) {
2478                 /* Nothing is here. See below */
2479         }
2480
2481         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2482 }
2483
2484 static int
2485 memb_id_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2486                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2487         long value;
2488
2489         if(!sptr) {
2490                 ASN__CTFAIL(app_key, td, sptr,
2491                         "%s: value not given (%s:%d)",
2492                         td->name, __FILE__, __LINE__);
2493                 return -1;
2494         }
2495
2496         value = *(const long *)sptr;
2497
2498         if((value >= 0 && value <= 65535)) {
2499                 /* Constraint check succeeded */
2500                 return 0;
2501         } else {
2502                 ASN__CTFAIL(app_key, td, sptr,
2503                         "%s: constraint failed (%s:%d)",
2504                         td->name, __FILE__, __LINE__);
2505                 return -1;
2506         }
2507 }
2508
2509 static asn_type_selector_result_t
2510 select_RICsubscriptionDeleteRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2511         asn_type_selector_result_t result = {0, 0};
2512         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteRequest_IEs_1;
2513         size_t constraining_column = 0; /* &id */
2514         size_t for_column = 1; /* &criticality */
2515         size_t row, presence_index = 0;
2516         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteRequest_IEs, id));
2517
2518         for(row=0; row < itable->rows_count; row++) {
2519             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2520             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2521
2522             if(type_cell->cell_kind == aioc__undefined)
2523                 continue;
2524
2525             presence_index++;
2526             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2527                 result.type_descriptor = type_cell->type_descriptor;
2528                 result.presence_index = presence_index;
2529                 break;
2530             }
2531         }
2532
2533         return result;
2534 }
2535
2536 static int
2537 memb_criticality_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2538                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2539
2540         if(!sptr) {
2541                 ASN__CTFAIL(app_key, td, sptr,
2542                         "%s: value not given (%s:%d)",
2543                         td->name, __FILE__, __LINE__);
2544                 return -1;
2545         }
2546
2547
2548         if(1 /* No applicable constraints whatsoever */) {
2549                 /* Nothing is here. See below */
2550         }
2551
2552         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2553 }
2554
2555 static asn_type_selector_result_t
2556 select_RICsubscriptionDeleteRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2557         asn_type_selector_result_t result = {0, 0};
2558         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteRequest_IEs_1;
2559         size_t constraining_column = 0; /* &id */
2560         size_t for_column = 2; /* &Value */
2561         size_t row, presence_index = 0;
2562         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteRequest_IEs, id));
2563
2564         for(row=0; row < itable->rows_count; row++) {
2565             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2566             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2567
2568             if(type_cell->cell_kind == aioc__undefined)
2569                 continue;
2570
2571             presence_index++;
2572             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2573                 result.type_descriptor = type_cell->type_descriptor;
2574                 result.presence_index = presence_index;
2575                 break;
2576             }
2577         }
2578
2579         return result;
2580 }
2581
2582 static int
2583 memb_value_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2584                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2585
2586         if(!sptr) {
2587                 ASN__CTFAIL(app_key, td, sptr,
2588                         "%s: value not given (%s:%d)",
2589                         td->name, __FILE__, __LINE__);
2590                 return -1;
2591         }
2592
2593
2594         if(1 /* No applicable constraints whatsoever */) {
2595                 /* Nothing is here. See below */
2596         }
2597
2598         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2599 }
2600
2601 static int
2602 memb_id_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2603                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2604         long value;
2605
2606         if(!sptr) {
2607                 ASN__CTFAIL(app_key, td, sptr,
2608                         "%s: value not given (%s:%d)",
2609                         td->name, __FILE__, __LINE__);
2610                 return -1;
2611         }
2612
2613         value = *(const long *)sptr;
2614
2615         if((value >= 0 && value <= 65535)) {
2616                 /* Constraint check succeeded */
2617                 return 0;
2618         } else {
2619                 ASN__CTFAIL(app_key, td, sptr,
2620                         "%s: constraint failed (%s:%d)",
2621                         td->name, __FILE__, __LINE__);
2622                 return -1;
2623         }
2624 }
2625
2626 static asn_type_selector_result_t
2627 select_RICsubscriptionDeleteResponse_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2628         asn_type_selector_result_t result = {0, 0};
2629         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteResponse_IEs_1;
2630         size_t constraining_column = 0; /* &id */
2631         size_t for_column = 1; /* &criticality */
2632         size_t row, presence_index = 0;
2633         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteResponse_IEs, id));
2634
2635         for(row=0; row < itable->rows_count; row++) {
2636             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2637             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2638
2639             if(type_cell->cell_kind == aioc__undefined)
2640                 continue;
2641
2642             presence_index++;
2643             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2644                 result.type_descriptor = type_cell->type_descriptor;
2645                 result.presence_index = presence_index;
2646                 break;
2647             }
2648         }
2649
2650         return result;
2651 }
2652
2653 static int
2654 memb_criticality_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2655                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2656
2657         if(!sptr) {
2658                 ASN__CTFAIL(app_key, td, sptr,
2659                         "%s: value not given (%s:%d)",
2660                         td->name, __FILE__, __LINE__);
2661                 return -1;
2662         }
2663
2664
2665         if(1 /* No applicable constraints whatsoever */) {
2666                 /* Nothing is here. See below */
2667         }
2668
2669         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2670 }
2671
2672 static asn_type_selector_result_t
2673 select_RICsubscriptionDeleteResponse_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2674         asn_type_selector_result_t result = {0, 0};
2675         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteResponse_IEs_1;
2676         size_t constraining_column = 0; /* &id */
2677         size_t for_column = 2; /* &Value */
2678         size_t row, presence_index = 0;
2679         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteResponse_IEs, id));
2680
2681         for(row=0; row < itable->rows_count; row++) {
2682             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2683             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2684
2685             if(type_cell->cell_kind == aioc__undefined)
2686                 continue;
2687
2688             presence_index++;
2689             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2690                 result.type_descriptor = type_cell->type_descriptor;
2691                 result.presence_index = presence_index;
2692                 break;
2693             }
2694         }
2695
2696         return result;
2697 }
2698
2699 static int
2700 memb_value_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2701                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2702
2703         if(!sptr) {
2704                 ASN__CTFAIL(app_key, td, sptr,
2705                         "%s: value not given (%s:%d)",
2706                         td->name, __FILE__, __LINE__);
2707                 return -1;
2708         }
2709
2710
2711         if(1 /* No applicable constraints whatsoever */) {
2712                 /* Nothing is here. See below */
2713         }
2714
2715         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2716 }
2717
2718 static int
2719 memb_id_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2720                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2721         long value;
2722
2723         if(!sptr) {
2724                 ASN__CTFAIL(app_key, td, sptr,
2725                         "%s: value not given (%s:%d)",
2726                         td->name, __FILE__, __LINE__);
2727                 return -1;
2728         }
2729
2730         value = *(const long *)sptr;
2731
2732         if((value >= 0 && value <= 65535)) {
2733                 /* Constraint check succeeded */
2734                 return 0;
2735         } else {
2736                 ASN__CTFAIL(app_key, td, sptr,
2737                         "%s: constraint failed (%s:%d)",
2738                         td->name, __FILE__, __LINE__);
2739                 return -1;
2740         }
2741 }
2742
2743 static asn_type_selector_result_t
2744 select_RICsubscriptionDeleteFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2745         asn_type_selector_result_t result = {0, 0};
2746         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteFailure_IEs_1;
2747         size_t constraining_column = 0; /* &id */
2748         size_t for_column = 1; /* &criticality */
2749         size_t row, presence_index = 0;
2750         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteFailure_IEs, id));
2751
2752         for(row=0; row < itable->rows_count; row++) {
2753             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2754             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2755
2756             if(type_cell->cell_kind == aioc__undefined)
2757                 continue;
2758
2759             presence_index++;
2760             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2761                 result.type_descriptor = type_cell->type_descriptor;
2762                 result.presence_index = presence_index;
2763                 break;
2764             }
2765         }
2766
2767         return result;
2768 }
2769
2770 static int
2771 memb_criticality_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2772                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2773
2774         if(!sptr) {
2775                 ASN__CTFAIL(app_key, td, sptr,
2776                         "%s: value not given (%s:%d)",
2777                         td->name, __FILE__, __LINE__);
2778                 return -1;
2779         }
2780
2781
2782         if(1 /* No applicable constraints whatsoever */) {
2783                 /* Nothing is here. See below */
2784         }
2785
2786         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2787 }
2788
2789 static asn_type_selector_result_t
2790 select_RICsubscriptionDeleteFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2791         asn_type_selector_result_t result = {0, 0};
2792         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteFailure_IEs_1;
2793         size_t constraining_column = 0; /* &id */
2794         size_t for_column = 2; /* &Value */
2795         size_t row, presence_index = 0;
2796         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteFailure_IEs, id));
2797
2798         for(row=0; row < itable->rows_count; row++) {
2799             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2800             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2801
2802             if(type_cell->cell_kind == aioc__undefined)
2803                 continue;
2804
2805             presence_index++;
2806             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2807                 result.type_descriptor = type_cell->type_descriptor;
2808                 result.presence_index = presence_index;
2809                 break;
2810             }
2811         }
2812
2813         return result;
2814 }
2815
2816 static int
2817 memb_value_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2818                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2819
2820         if(!sptr) {
2821                 ASN__CTFAIL(app_key, td, sptr,
2822                         "%s: value not given (%s:%d)",
2823                         td->name, __FILE__, __LINE__);
2824                 return -1;
2825         }
2826
2827
2828         if(1 /* No applicable constraints whatsoever */) {
2829                 /* Nothing is here. See below */
2830         }
2831
2832         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2833 }
2834
2835 static int
2836 memb_id_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2837                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2838         long value;
2839
2840         if(!sptr) {
2841                 ASN__CTFAIL(app_key, td, sptr,
2842                         "%s: value not given (%s:%d)",
2843                         td->name, __FILE__, __LINE__);
2844                 return -1;
2845         }
2846
2847         value = *(const long *)sptr;
2848
2849         if((value >= 0 && value <= 65535)) {
2850                 /* Constraint check succeeded */
2851                 return 0;
2852         } else {
2853                 ASN__CTFAIL(app_key, td, sptr,
2854                         "%s: constraint failed (%s:%d)",
2855                         td->name, __FILE__, __LINE__);
2856                 return -1;
2857         }
2858 }
2859
2860 static asn_type_selector_result_t
2861 select_RICindication_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2862         asn_type_selector_result_t result = {0, 0};
2863         const asn_ioc_set_t *itable = asn_IOS_RICindication_IEs_1;
2864         size_t constraining_column = 0; /* &id */
2865         size_t for_column = 1; /* &criticality */
2866         size_t row, presence_index = 0;
2867         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICindication_IEs, id));
2868
2869         for(row=0; row < itable->rows_count; row++) {
2870             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2871             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2872
2873             if(type_cell->cell_kind == aioc__undefined)
2874                 continue;
2875
2876             presence_index++;
2877             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2878                 result.type_descriptor = type_cell->type_descriptor;
2879                 result.presence_index = presence_index;
2880                 break;
2881             }
2882         }
2883
2884         return result;
2885 }
2886
2887 static int
2888 memb_criticality_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2889                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2890
2891         if(!sptr) {
2892                 ASN__CTFAIL(app_key, td, sptr,
2893                         "%s: value not given (%s:%d)",
2894                         td->name, __FILE__, __LINE__);
2895                 return -1;
2896         }
2897
2898
2899         if(1 /* No applicable constraints whatsoever */) {
2900                 /* Nothing is here. See below */
2901         }
2902
2903         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2904 }
2905
2906 static asn_type_selector_result_t
2907 select_RICindication_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2908         asn_type_selector_result_t result = {0, 0};
2909         const asn_ioc_set_t *itable = asn_IOS_RICindication_IEs_1;
2910         size_t constraining_column = 0; /* &id */
2911         size_t for_column = 2; /* &Value */
2912         size_t row, presence_index = 0;
2913         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICindication_IEs, id));
2914
2915         for(row=0; row < itable->rows_count; row++) {
2916             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2917             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2918
2919             if(type_cell->cell_kind == aioc__undefined)
2920                 continue;
2921
2922             presence_index++;
2923             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2924                 result.type_descriptor = type_cell->type_descriptor;
2925                 result.presence_index = presence_index;
2926                 break;
2927             }
2928         }
2929
2930         return result;
2931 }
2932
2933 static int
2934 memb_value_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2935                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2936
2937         if(!sptr) {
2938                 ASN__CTFAIL(app_key, td, sptr,
2939                         "%s: value not given (%s:%d)",
2940                         td->name, __FILE__, __LINE__);
2941                 return -1;
2942         }
2943
2944
2945         if(1 /* No applicable constraints whatsoever */) {
2946                 /* Nothing is here. See below */
2947         }
2948
2949         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2950 }
2951
2952 static int
2953 memb_id_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2954                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2955         long value;
2956
2957         if(!sptr) {
2958                 ASN__CTFAIL(app_key, td, sptr,
2959                         "%s: value not given (%s:%d)",
2960                         td->name, __FILE__, __LINE__);
2961                 return -1;
2962         }
2963
2964         value = *(const long *)sptr;
2965
2966         if((value >= 0 && value <= 65535)) {
2967                 /* Constraint check succeeded */
2968                 return 0;
2969         } else {
2970                 ASN__CTFAIL(app_key, td, sptr,
2971                         "%s: constraint failed (%s:%d)",
2972                         td->name, __FILE__, __LINE__);
2973                 return -1;
2974         }
2975 }
2976
2977 static asn_type_selector_result_t
2978 select_RICcontrolRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2979         asn_type_selector_result_t result = {0, 0};
2980         const asn_ioc_set_t *itable = asn_IOS_RICcontrolRequest_IEs_1;
2981         size_t constraining_column = 0; /* &id */
2982         size_t for_column = 1; /* &criticality */
2983         size_t row, presence_index = 0;
2984         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolRequest_IEs, id));
2985
2986         for(row=0; row < itable->rows_count; row++) {
2987             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2988             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2989
2990             if(type_cell->cell_kind == aioc__undefined)
2991                 continue;
2992
2993             presence_index++;
2994             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2995                 result.type_descriptor = type_cell->type_descriptor;
2996                 result.presence_index = presence_index;
2997                 break;
2998             }
2999         }
3000
3001         return result;
3002 }
3003
3004 static int
3005 memb_criticality_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
3006                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3007
3008         if(!sptr) {
3009                 ASN__CTFAIL(app_key, td, sptr,
3010                         "%s: value not given (%s:%d)",
3011                         td->name, __FILE__, __LINE__);
3012                 return -1;
3013         }
3014
3015
3016         if(1 /* No applicable constraints whatsoever */) {
3017                 /* Nothing is here. See below */
3018         }
3019
3020         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3021 }
3022
3023 static asn_type_selector_result_t
3024 select_RICcontrolRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3025         asn_type_selector_result_t result = {0, 0};
3026         const asn_ioc_set_t *itable = asn_IOS_RICcontrolRequest_IEs_1;
3027         size_t constraining_column = 0; /* &id */
3028         size_t for_column = 2; /* &Value */
3029         size_t row, presence_index = 0;
3030         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolRequest_IEs, id));
3031
3032         for(row=0; row < itable->rows_count; row++) {
3033             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3034             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3035
3036             if(type_cell->cell_kind == aioc__undefined)
3037                 continue;
3038
3039             presence_index++;
3040             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3041                 result.type_descriptor = type_cell->type_descriptor;
3042                 result.presence_index = presence_index;
3043                 break;
3044             }
3045         }
3046
3047         return result;
3048 }
3049
3050 static int
3051 memb_value_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
3052                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3053
3054         if(!sptr) {
3055                 ASN__CTFAIL(app_key, td, sptr,
3056                         "%s: value not given (%s:%d)",
3057                         td->name, __FILE__, __LINE__);
3058                 return -1;
3059         }
3060
3061
3062         if(1 /* No applicable constraints whatsoever */) {
3063                 /* Nothing is here. See below */
3064         }
3065
3066         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3067 }
3068
3069 static int
3070 memb_id_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
3071                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3072         long value;
3073
3074         if(!sptr) {
3075                 ASN__CTFAIL(app_key, td, sptr,
3076                         "%s: value not given (%s:%d)",
3077                         td->name, __FILE__, __LINE__);
3078                 return -1;
3079         }
3080
3081         value = *(const long *)sptr;
3082
3083         if((value >= 0 && value <= 65535)) {
3084                 /* Constraint check succeeded */
3085                 return 0;
3086         } else {
3087                 ASN__CTFAIL(app_key, td, sptr,
3088                         "%s: constraint failed (%s:%d)",
3089                         td->name, __FILE__, __LINE__);
3090                 return -1;
3091         }
3092 }
3093
3094 static asn_type_selector_result_t
3095 select_RICcontrolAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3096         asn_type_selector_result_t result = {0, 0};
3097         const asn_ioc_set_t *itable = asn_IOS_RICcontrolAcknowledge_IEs_1;
3098         size_t constraining_column = 0; /* &id */
3099         size_t for_column = 1; /* &criticality */
3100         size_t row, presence_index = 0;
3101         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolAcknowledge_IEs, id));
3102
3103         for(row=0; row < itable->rows_count; row++) {
3104             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3105             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3106
3107             if(type_cell->cell_kind == aioc__undefined)
3108                 continue;
3109
3110             presence_index++;
3111             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3112                 result.type_descriptor = type_cell->type_descriptor;
3113                 result.presence_index = presence_index;
3114                 break;
3115             }
3116         }
3117
3118         return result;
3119 }
3120
3121 static int
3122 memb_criticality_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
3123                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3124
3125         if(!sptr) {
3126                 ASN__CTFAIL(app_key, td, sptr,
3127                         "%s: value not given (%s:%d)",
3128                         td->name, __FILE__, __LINE__);
3129                 return -1;
3130         }
3131
3132
3133         if(1 /* No applicable constraints whatsoever */) {
3134                 /* Nothing is here. See below */
3135         }
3136
3137         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3138 }
3139
3140 static asn_type_selector_result_t
3141 select_RICcontrolAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3142         asn_type_selector_result_t result = {0, 0};
3143         const asn_ioc_set_t *itable = asn_IOS_RICcontrolAcknowledge_IEs_1;
3144         size_t constraining_column = 0; /* &id */
3145         size_t for_column = 2; /* &Value */
3146         size_t row, presence_index = 0;
3147         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolAcknowledge_IEs, id));
3148
3149         for(row=0; row < itable->rows_count; row++) {
3150             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3151             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3152
3153             if(type_cell->cell_kind == aioc__undefined)
3154                 continue;
3155
3156             presence_index++;
3157             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3158                 result.type_descriptor = type_cell->type_descriptor;
3159                 result.presence_index = presence_index;
3160                 break;
3161             }
3162         }
3163
3164         return result;
3165 }
3166
3167 static int
3168 memb_value_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
3169                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3170
3171         if(!sptr) {
3172                 ASN__CTFAIL(app_key, td, sptr,
3173                         "%s: value not given (%s:%d)",
3174                         td->name, __FILE__, __LINE__);
3175                 return -1;
3176         }
3177
3178
3179         if(1 /* No applicable constraints whatsoever */) {
3180                 /* Nothing is here. See below */
3181         }
3182
3183         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3184 }
3185
3186 static int
3187 memb_id_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3188                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3189         long value;
3190
3191         if(!sptr) {
3192                 ASN__CTFAIL(app_key, td, sptr,
3193                         "%s: value not given (%s:%d)",
3194                         td->name, __FILE__, __LINE__);
3195                 return -1;
3196         }
3197
3198         value = *(const long *)sptr;
3199
3200         if((value >= 0 && value <= 65535)) {
3201                 /* Constraint check succeeded */
3202                 return 0;
3203         } else {
3204                 ASN__CTFAIL(app_key, td, sptr,
3205                         "%s: constraint failed (%s:%d)",
3206                         td->name, __FILE__, __LINE__);
3207                 return -1;
3208         }
3209 }
3210
3211 static asn_type_selector_result_t
3212 select_RICcontrolFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3213         asn_type_selector_result_t result = {0, 0};
3214         const asn_ioc_set_t *itable = asn_IOS_RICcontrolFailure_IEs_1;
3215         size_t constraining_column = 0; /* &id */
3216         size_t for_column = 1; /* &criticality */
3217         size_t row, presence_index = 0;
3218         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolFailure_IEs, id));
3219
3220         for(row=0; row < itable->rows_count; row++) {
3221             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3222             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3223
3224             if(type_cell->cell_kind == aioc__undefined)
3225                 continue;
3226
3227             presence_index++;
3228             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3229                 result.type_descriptor = type_cell->type_descriptor;
3230                 result.presence_index = presence_index;
3231                 break;
3232             }
3233         }
3234
3235         return result;
3236 }
3237
3238 static int
3239 memb_criticality_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3240                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3241
3242         if(!sptr) {
3243                 ASN__CTFAIL(app_key, td, sptr,
3244                         "%s: value not given (%s:%d)",
3245                         td->name, __FILE__, __LINE__);
3246                 return -1;
3247         }
3248
3249
3250         if(1 /* No applicable constraints whatsoever */) {
3251                 /* Nothing is here. See below */
3252         }
3253
3254         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3255 }
3256
3257 static asn_type_selector_result_t
3258 select_RICcontrolFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3259         asn_type_selector_result_t result = {0, 0};
3260         const asn_ioc_set_t *itable = asn_IOS_RICcontrolFailure_IEs_1;
3261         size_t constraining_column = 0; /* &id */
3262         size_t for_column = 2; /* &Value */
3263         size_t row, presence_index = 0;
3264         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolFailure_IEs, id));
3265
3266         for(row=0; row < itable->rows_count; row++) {
3267             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3268             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3269
3270             if(type_cell->cell_kind == aioc__undefined)
3271                 continue;
3272
3273             presence_index++;
3274             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3275                 result.type_descriptor = type_cell->type_descriptor;
3276                 result.presence_index = presence_index;
3277                 break;
3278             }
3279         }
3280
3281         return result;
3282 }
3283
3284 static int
3285 memb_value_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3286                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3287
3288         if(!sptr) {
3289                 ASN__CTFAIL(app_key, td, sptr,
3290                         "%s: value not given (%s:%d)",
3291                         td->name, __FILE__, __LINE__);
3292                 return -1;
3293         }
3294
3295
3296         if(1 /* No applicable constraints whatsoever */) {
3297                 /* Nothing is here. See below */
3298         }
3299
3300         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3301 }
3302
3303 static int
3304 memb_id_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3305                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3306         long value;
3307
3308         if(!sptr) {
3309                 ASN__CTFAIL(app_key, td, sptr,
3310                         "%s: value not given (%s:%d)",
3311                         td->name, __FILE__, __LINE__);
3312                 return -1;
3313         }
3314
3315         value = *(const long *)sptr;
3316
3317         if((value >= 0 && value <= 65535)) {
3318                 /* Constraint check succeeded */
3319                 return 0;
3320         } else {
3321                 ASN__CTFAIL(app_key, td, sptr,
3322                         "%s: constraint failed (%s:%d)",
3323                         td->name, __FILE__, __LINE__);
3324                 return -1;
3325         }
3326 }
3327
3328 static asn_type_selector_result_t
3329 select_ErrorIndication_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3330         asn_type_selector_result_t result = {0, 0};
3331         const asn_ioc_set_t *itable = asn_IOS_ErrorIndication_IEs_1;
3332         size_t constraining_column = 0; /* &id */
3333         size_t for_column = 1; /* &criticality */
3334         size_t row, presence_index = 0;
3335         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ErrorIndication_IEs, id));
3336
3337         for(row=0; row < itable->rows_count; row++) {
3338             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3339             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3340
3341             if(type_cell->cell_kind == aioc__undefined)
3342                 continue;
3343
3344             presence_index++;
3345             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3346                 result.type_descriptor = type_cell->type_descriptor;
3347                 result.presence_index = presence_index;
3348                 break;
3349             }
3350         }
3351
3352         return result;
3353 }
3354
3355 static int
3356 memb_criticality_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3357                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3358
3359         if(!sptr) {
3360                 ASN__CTFAIL(app_key, td, sptr,
3361                         "%s: value not given (%s:%d)",
3362                         td->name, __FILE__, __LINE__);
3363                 return -1;
3364         }
3365
3366
3367         if(1 /* No applicable constraints whatsoever */) {
3368                 /* Nothing is here. See below */
3369         }
3370
3371         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3372 }
3373
3374 static asn_type_selector_result_t
3375 select_ErrorIndication_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3376         asn_type_selector_result_t result = {0, 0};
3377         const asn_ioc_set_t *itable = asn_IOS_ErrorIndication_IEs_1;
3378         size_t constraining_column = 0; /* &id */
3379         size_t for_column = 2; /* &Value */
3380         size_t row, presence_index = 0;
3381         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ErrorIndication_IEs, id));
3382
3383         for(row=0; row < itable->rows_count; row++) {
3384             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3385             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3386
3387             if(type_cell->cell_kind == aioc__undefined)
3388                 continue;
3389
3390             presence_index++;
3391             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3392                 result.type_descriptor = type_cell->type_descriptor;
3393                 result.presence_index = presence_index;
3394                 break;
3395             }
3396         }
3397
3398         return result;
3399 }
3400
3401 static int
3402 memb_value_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3403                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3404
3405         if(!sptr) {
3406                 ASN__CTFAIL(app_key, td, sptr,
3407                         "%s: value not given (%s:%d)",
3408                         td->name, __FILE__, __LINE__);
3409                 return -1;
3410         }
3411
3412
3413         if(1 /* No applicable constraints whatsoever */) {
3414                 /* Nothing is here. See below */
3415         }
3416
3417         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3418 }
3419
3420 static int
3421 memb_id_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3422                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3423         long value;
3424
3425         if(!sptr) {
3426                 ASN__CTFAIL(app_key, td, sptr,
3427                         "%s: value not given (%s:%d)",
3428                         td->name, __FILE__, __LINE__);
3429                 return -1;
3430         }
3431
3432         value = *(const long *)sptr;
3433
3434         if((value >= 0 && value <= 65535)) {
3435                 /* Constraint check succeeded */
3436                 return 0;
3437         } else {
3438                 ASN__CTFAIL(app_key, td, sptr,
3439                         "%s: constraint failed (%s:%d)",
3440                         td->name, __FILE__, __LINE__);
3441                 return -1;
3442         }
3443 }
3444
3445 static asn_type_selector_result_t
3446 select_E2setupRequestIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3447         asn_type_selector_result_t result = {0, 0};
3448         const asn_ioc_set_t *itable = asn_IOS_E2setupRequestIEs_1;
3449         size_t constraining_column = 0; /* &id */
3450         size_t for_column = 1; /* &criticality */
3451         size_t row, presence_index = 0;
3452         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupRequestIEs, id));
3453
3454         for(row=0; row < itable->rows_count; row++) {
3455             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3456             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3457
3458             if(type_cell->cell_kind == aioc__undefined)
3459                 continue;
3460
3461             presence_index++;
3462             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3463                 result.type_descriptor = type_cell->type_descriptor;
3464                 result.presence_index = presence_index;
3465                 break;
3466             }
3467         }
3468
3469         return result;
3470 }
3471
3472 static int
3473 memb_criticality_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3474                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3475
3476         if(!sptr) {
3477                 ASN__CTFAIL(app_key, td, sptr,
3478                         "%s: value not given (%s:%d)",
3479                         td->name, __FILE__, __LINE__);
3480                 return -1;
3481         }
3482
3483
3484         if(1 /* No applicable constraints whatsoever */) {
3485                 /* Nothing is here. See below */
3486         }
3487
3488         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3489 }
3490
3491 static asn_type_selector_result_t
3492 select_E2setupRequestIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3493         asn_type_selector_result_t result = {0, 0};
3494         const asn_ioc_set_t *itable = asn_IOS_E2setupRequestIEs_1;
3495         size_t constraining_column = 0; /* &id */
3496         size_t for_column = 2; /* &Value */
3497         size_t row, presence_index = 0;
3498         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupRequestIEs, id));
3499
3500         for(row=0; row < itable->rows_count; row++) {
3501             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3502             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3503
3504             if(type_cell->cell_kind == aioc__undefined)
3505                 continue;
3506
3507             presence_index++;
3508             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3509                 result.type_descriptor = type_cell->type_descriptor;
3510                 result.presence_index = presence_index;
3511                 break;
3512             }
3513         }
3514
3515         return result;
3516 }
3517
3518 static int
3519 memb_value_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3520                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3521
3522         if(!sptr) {
3523                 ASN__CTFAIL(app_key, td, sptr,
3524                         "%s: value not given (%s:%d)",
3525                         td->name, __FILE__, __LINE__);
3526                 return -1;
3527         }
3528
3529
3530         if(1 /* No applicable constraints whatsoever */) {
3531                 /* Nothing is here. See below */
3532         }
3533
3534         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3535 }
3536
3537 static int
3538 memb_id_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3539                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3540         long value;
3541
3542         if(!sptr) {
3543                 ASN__CTFAIL(app_key, td, sptr,
3544                         "%s: value not given (%s:%d)",
3545                         td->name, __FILE__, __LINE__);
3546                 return -1;
3547         }
3548
3549         value = *(const long *)sptr;
3550
3551         if((value >= 0 && value <= 65535)) {
3552                 /* Constraint check succeeded */
3553                 return 0;
3554         } else {
3555                 ASN__CTFAIL(app_key, td, sptr,
3556                         "%s: constraint failed (%s:%d)",
3557                         td->name, __FILE__, __LINE__);
3558                 return -1;
3559         }
3560 }
3561
3562 static asn_type_selector_result_t
3563 select_E2setupResponseIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3564         asn_type_selector_result_t result = {0, 0};
3565         const asn_ioc_set_t *itable = asn_IOS_E2setupResponseIEs_1;
3566         size_t constraining_column = 0; /* &id */
3567         size_t for_column = 1; /* &criticality */
3568         size_t row, presence_index = 0;
3569         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupResponseIEs, id));
3570
3571         for(row=0; row < itable->rows_count; row++) {
3572             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3573             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3574
3575             if(type_cell->cell_kind == aioc__undefined)
3576                 continue;
3577
3578             presence_index++;
3579             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3580                 result.type_descriptor = type_cell->type_descriptor;
3581                 result.presence_index = presence_index;
3582                 break;
3583             }
3584         }
3585
3586         return result;
3587 }
3588
3589 static int
3590 memb_criticality_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3591                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3592
3593         if(!sptr) {
3594                 ASN__CTFAIL(app_key, td, sptr,
3595                         "%s: value not given (%s:%d)",
3596                         td->name, __FILE__, __LINE__);
3597                 return -1;
3598         }
3599
3600
3601         if(1 /* No applicable constraints whatsoever */) {
3602                 /* Nothing is here. See below */
3603         }
3604
3605         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3606 }
3607
3608 static asn_type_selector_result_t
3609 select_E2setupResponseIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3610         asn_type_selector_result_t result = {0, 0};
3611         const asn_ioc_set_t *itable = asn_IOS_E2setupResponseIEs_1;
3612         size_t constraining_column = 0; /* &id */
3613         size_t for_column = 2; /* &Value */
3614         size_t row, presence_index = 0;
3615         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupResponseIEs, id));
3616
3617         for(row=0; row < itable->rows_count; row++) {
3618             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3619             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3620
3621             if(type_cell->cell_kind == aioc__undefined)
3622                 continue;
3623
3624             presence_index++;
3625             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3626                 result.type_descriptor = type_cell->type_descriptor;
3627                 result.presence_index = presence_index;
3628                 break;
3629             }
3630         }
3631
3632         return result;
3633 }
3634
3635 static int
3636 memb_value_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3637                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3638
3639         if(!sptr) {
3640                 ASN__CTFAIL(app_key, td, sptr,
3641                         "%s: value not given (%s:%d)",
3642                         td->name, __FILE__, __LINE__);
3643                 return -1;
3644         }
3645
3646
3647         if(1 /* No applicable constraints whatsoever */) {
3648                 /* Nothing is here. See below */
3649         }
3650
3651         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3652 }
3653
3654 static int
3655 memb_id_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3656                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3657         long value;
3658
3659         if(!sptr) {
3660                 ASN__CTFAIL(app_key, td, sptr,
3661                         "%s: value not given (%s:%d)",
3662                         td->name, __FILE__, __LINE__);
3663                 return -1;
3664         }
3665
3666         value = *(const long *)sptr;
3667
3668         if((value >= 0 && value <= 65535)) {
3669                 /* Constraint check succeeded */
3670                 return 0;
3671         } else {
3672                 ASN__CTFAIL(app_key, td, sptr,
3673                         "%s: constraint failed (%s:%d)",
3674                         td->name, __FILE__, __LINE__);
3675                 return -1;
3676         }
3677 }
3678
3679 static asn_type_selector_result_t
3680 select_E2setupFailureIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3681         asn_type_selector_result_t result = {0, 0};
3682         const asn_ioc_set_t *itable = asn_IOS_E2setupFailureIEs_1;
3683         size_t constraining_column = 0; /* &id */
3684         size_t for_column = 1; /* &criticality */
3685         size_t row, presence_index = 0;
3686         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupFailureIEs, id));
3687
3688         for(row=0; row < itable->rows_count; row++) {
3689             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3690             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3691
3692             if(type_cell->cell_kind == aioc__undefined)
3693                 continue;
3694
3695             presence_index++;
3696             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3697                 result.type_descriptor = type_cell->type_descriptor;
3698                 result.presence_index = presence_index;
3699                 break;
3700             }
3701         }
3702
3703         return result;
3704 }
3705
3706 static int
3707 memb_criticality_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3708                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3709
3710         if(!sptr) {
3711                 ASN__CTFAIL(app_key, td, sptr,
3712                         "%s: value not given (%s:%d)",
3713                         td->name, __FILE__, __LINE__);
3714                 return -1;
3715         }
3716
3717
3718         if(1 /* No applicable constraints whatsoever */) {
3719                 /* Nothing is here. See below */
3720         }
3721
3722         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3723 }
3724
3725 static asn_type_selector_result_t
3726 select_E2setupFailureIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3727         asn_type_selector_result_t result = {0, 0};
3728         const asn_ioc_set_t *itable = asn_IOS_E2setupFailureIEs_1;
3729         size_t constraining_column = 0; /* &id */
3730         size_t for_column = 2; /* &Value */
3731         size_t row, presence_index = 0;
3732         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupFailureIEs, id));
3733
3734         for(row=0; row < itable->rows_count; row++) {
3735             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3736             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3737
3738             if(type_cell->cell_kind == aioc__undefined)
3739                 continue;
3740
3741             presence_index++;
3742             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3743                 result.type_descriptor = type_cell->type_descriptor;
3744                 result.presence_index = presence_index;
3745                 break;
3746             }
3747         }
3748
3749         return result;
3750 }
3751
3752 static int
3753 memb_value_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3754                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3755
3756         if(!sptr) {
3757                 ASN__CTFAIL(app_key, td, sptr,
3758                         "%s: value not given (%s:%d)",
3759                         td->name, __FILE__, __LINE__);
3760                 return -1;
3761         }
3762
3763
3764         if(1 /* No applicable constraints whatsoever */) {
3765                 /* Nothing is here. See below */
3766         }
3767
3768         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3769 }
3770
3771 static int
3772 memb_id_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3773                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3774         long value;
3775
3776         if(!sptr) {
3777                 ASN__CTFAIL(app_key, td, sptr,
3778                         "%s: value not given (%s:%d)",
3779                         td->name, __FILE__, __LINE__);
3780                 return -1;
3781         }
3782
3783         value = *(const long *)sptr;
3784
3785         if((value >= 0 && value <= 65535)) {
3786                 /* Constraint check succeeded */
3787                 return 0;
3788         } else {
3789                 ASN__CTFAIL(app_key, td, sptr,
3790                         "%s: constraint failed (%s:%d)",
3791                         td->name, __FILE__, __LINE__);
3792                 return -1;
3793         }
3794 }
3795
3796 static asn_type_selector_result_t
3797 select_E2connectionUpdate_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3798         asn_type_selector_result_t result = {0, 0};
3799         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdate_IEs_1;
3800         size_t constraining_column = 0; /* &id */
3801         size_t for_column = 1; /* &criticality */
3802         size_t row, presence_index = 0;
3803         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdate_IEs, id));
3804
3805         for(row=0; row < itable->rows_count; row++) {
3806             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3807             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3808
3809             if(type_cell->cell_kind == aioc__undefined)
3810                 continue;
3811
3812             presence_index++;
3813             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3814                 result.type_descriptor = type_cell->type_descriptor;
3815                 result.presence_index = presence_index;
3816                 break;
3817             }
3818         }
3819
3820         return result;
3821 }
3822
3823 static int
3824 memb_criticality_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3825                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3826
3827         if(!sptr) {
3828                 ASN__CTFAIL(app_key, td, sptr,
3829                         "%s: value not given (%s:%d)",
3830                         td->name, __FILE__, __LINE__);
3831                 return -1;
3832         }
3833
3834
3835         if(1 /* No applicable constraints whatsoever */) {
3836                 /* Nothing is here. See below */
3837         }
3838
3839         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3840 }
3841
3842 static asn_type_selector_result_t
3843 select_E2connectionUpdate_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3844         asn_type_selector_result_t result = {0, 0};
3845         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdate_IEs_1;
3846         size_t constraining_column = 0; /* &id */
3847         size_t for_column = 2; /* &Value */
3848         size_t row, presence_index = 0;
3849         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdate_IEs, id));
3850         const int indexToPresence[4] = {
3851                 E2connectionUpdate_IEs__value_PR_NOTHING,
3852                 E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List,
3853                 E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List,
3854                 E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List
3855         };
3856
3857         for(row=0; row < itable->rows_count; row++) {
3858             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3859             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3860
3861             if(type_cell->cell_kind == aioc__undefined)
3862                 continue;
3863
3864             presence_index++;
3865             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3866                 result.type_descriptor = type_cell->type_descriptor;
3867                 result.presence_index = indexToPresence[presence_index];
3868                 break;
3869             }
3870         }
3871
3872         return result;
3873 }
3874
3875 static int
3876 memb_value_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3877                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3878
3879         if(!sptr) {
3880                 ASN__CTFAIL(app_key, td, sptr,
3881                         "%s: value not given (%s:%d)",
3882                         td->name, __FILE__, __LINE__);
3883                 return -1;
3884         }
3885
3886
3887         if(1 /* No applicable constraints whatsoever */) {
3888                 /* Nothing is here. See below */
3889         }
3890
3891         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3892 }
3893
3894 static int
3895 memb_id_constraint_105(const asn_TYPE_descriptor_t *td, const void *sptr,
3896                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3897         long value;
3898
3899         if(!sptr) {
3900                 ASN__CTFAIL(app_key, td, sptr,
3901                         "%s: value not given (%s:%d)",
3902                         td->name, __FILE__, __LINE__);
3903                 return -1;
3904         }
3905
3906         value = *(const long *)sptr;
3907
3908         if((value >= 0 && value <= 65535)) {
3909                 /* Constraint check succeeded */
3910                 return 0;
3911         } else {
3912                 ASN__CTFAIL(app_key, td, sptr,
3913                         "%s: constraint failed (%s:%d)",
3914                         td->name, __FILE__, __LINE__);
3915                 return -1;
3916         }
3917 }
3918
3919 static asn_type_selector_result_t
3920 select_E2connectionUpdateAck_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3921         asn_type_selector_result_t result = {0, 0};
3922         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdateAck_IEs_1;
3923         size_t constraining_column = 0; /* &id */
3924         size_t for_column = 1; /* &criticality */
3925         size_t row, presence_index = 0;
3926         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdateAck_IEs, id));
3927
3928         for(row=0; row < itable->rows_count; row++) {
3929             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3930             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3931
3932             if(type_cell->cell_kind == aioc__undefined)
3933                 continue;
3934
3935             presence_index++;
3936             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3937                 result.type_descriptor = type_cell->type_descriptor;
3938                 result.presence_index = presence_index;
3939                 break;
3940             }
3941         }
3942
3943         return result;
3944 }
3945
3946 static int
3947 memb_criticality_constraint_105(const asn_TYPE_descriptor_t *td, const void *sptr,
3948                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3949
3950         if(!sptr) {
3951                 ASN__CTFAIL(app_key, td, sptr,
3952                         "%s: value not given (%s:%d)",
3953                         td->name, __FILE__, __LINE__);
3954                 return -1;
3955         }
3956
3957
3958         if(1 /* No applicable constraints whatsoever */) {
3959                 /* Nothing is here. See below */
3960         }
3961
3962         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3963 }
3964
3965 static asn_type_selector_result_t
3966 select_E2connectionUpdateAck_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3967         asn_type_selector_result_t result = {0, 0};
3968         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdateAck_IEs_1;
3969         size_t constraining_column = 0; /* &id */
3970         size_t for_column = 2; /* &Value */
3971         size_t row, presence_index = 0;
3972         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdateAck_IEs, id));
3973
3974         for(row=0; row < itable->rows_count; row++) {
3975             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3976             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3977
3978             if(type_cell->cell_kind == aioc__undefined)
3979                 continue;
3980
3981             presence_index++;
3982             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3983                 result.type_descriptor = type_cell->type_descriptor;
3984                 result.presence_index = presence_index;
3985                 break;
3986             }
3987         }
3988
3989         return result;
3990 }
3991
3992 static int
3993 memb_value_constraint_105(const asn_TYPE_descriptor_t *td, const void *sptr,
3994                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3995
3996         if(!sptr) {
3997                 ASN__CTFAIL(app_key, td, sptr,
3998                         "%s: value not given (%s:%d)",
3999                         td->name, __FILE__, __LINE__);
4000                 return -1;
4001         }
4002
4003
4004         if(1 /* No applicable constraints whatsoever */) {
4005                 /* Nothing is here. See below */
4006         }
4007
4008         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4009 }
4010
4011 static int
4012 memb_id_constraint_109(const asn_TYPE_descriptor_t *td, const void *sptr,
4013                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4014         long value;
4015
4016         if(!sptr) {
4017                 ASN__CTFAIL(app_key, td, sptr,
4018                         "%s: value not given (%s:%d)",
4019                         td->name, __FILE__, __LINE__);
4020                 return -1;
4021         }
4022
4023         value = *(const long *)sptr;
4024
4025         if((value >= 0 && value <= 65535)) {
4026                 /* Constraint check succeeded */
4027                 return 0;
4028         } else {
4029                 ASN__CTFAIL(app_key, td, sptr,
4030                         "%s: constraint failed (%s:%d)",
4031                         td->name, __FILE__, __LINE__);
4032                 return -1;
4033         }
4034 }
4035
4036 static asn_type_selector_result_t
4037 select_E2connectionUpdateFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4038         asn_type_selector_result_t result = {0, 0};
4039         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdateFailure_IEs_1;
4040         size_t constraining_column = 0; /* &id */
4041         size_t for_column = 1; /* &criticality */
4042         size_t row, presence_index = 0;
4043         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdateFailure_IEs, id));
4044
4045         for(row=0; row < itable->rows_count; row++) {
4046             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4047             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4048
4049             if(type_cell->cell_kind == aioc__undefined)
4050                 continue;
4051
4052             presence_index++;
4053             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4054                 result.type_descriptor = type_cell->type_descriptor;
4055                 result.presence_index = presence_index;
4056                 break;
4057             }
4058         }
4059
4060         return result;
4061 }
4062
4063 static int
4064 memb_criticality_constraint_109(const asn_TYPE_descriptor_t *td, const void *sptr,
4065                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4066
4067         if(!sptr) {
4068                 ASN__CTFAIL(app_key, td, sptr,
4069                         "%s: value not given (%s:%d)",
4070                         td->name, __FILE__, __LINE__);
4071                 return -1;
4072         }
4073
4074
4075         if(1 /* No applicable constraints whatsoever */) {
4076                 /* Nothing is here. See below */
4077         }
4078
4079         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4080 }
4081
4082 static asn_type_selector_result_t
4083 select_E2connectionUpdateFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4084         asn_type_selector_result_t result = {0, 0};
4085         const asn_ioc_set_t *itable = asn_IOS_E2connectionUpdateFailure_IEs_1;
4086         size_t constraining_column = 0; /* &id */
4087         size_t for_column = 2; /* &Value */
4088         size_t row, presence_index = 0;
4089         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2connectionUpdateFailure_IEs, id));
4090
4091         for(row=0; row < itable->rows_count; row++) {
4092             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4093             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4094
4095             if(type_cell->cell_kind == aioc__undefined)
4096                 continue;
4097
4098             presence_index++;
4099             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4100                 result.type_descriptor = type_cell->type_descriptor;
4101                 result.presence_index = presence_index;
4102                 break;
4103             }
4104         }
4105
4106         return result;
4107 }
4108
4109 static int
4110 memb_value_constraint_109(const asn_TYPE_descriptor_t *td, const void *sptr,
4111                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4112
4113         if(!sptr) {
4114                 ASN__CTFAIL(app_key, td, sptr,
4115                         "%s: value not given (%s:%d)",
4116                         td->name, __FILE__, __LINE__);
4117                 return -1;
4118         }
4119
4120
4121         if(1 /* No applicable constraints whatsoever */) {
4122                 /* Nothing is here. See below */
4123         }
4124
4125         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4126 }
4127
4128 static int
4129 memb_id_constraint_113(const asn_TYPE_descriptor_t *td, const void *sptr,
4130                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4131         long value;
4132
4133         if(!sptr) {
4134                 ASN__CTFAIL(app_key, td, sptr,
4135                         "%s: value not given (%s:%d)",
4136                         td->name, __FILE__, __LINE__);
4137                 return -1;
4138         }
4139
4140         value = *(const long *)sptr;
4141
4142         if((value >= 0 && value <= 65535)) {
4143                 /* Constraint check succeeded */
4144                 return 0;
4145         } else {
4146                 ASN__CTFAIL(app_key, td, sptr,
4147                         "%s: constraint failed (%s:%d)",
4148                         td->name, __FILE__, __LINE__);
4149                 return -1;
4150         }
4151 }
4152
4153 static asn_type_selector_result_t
4154 select_E2nodeConfigurationUpdate_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4155         asn_type_selector_result_t result = {0, 0};
4156         const asn_ioc_set_t *itable = asn_IOS_E2nodeConfigurationUpdate_IEs_1;
4157         size_t constraining_column = 0; /* &id */
4158         size_t for_column = 1; /* &criticality */
4159         size_t row, presence_index = 0;
4160         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeConfigurationUpdate_IEs, id));
4161
4162         for(row=0; row < itable->rows_count; row++) {
4163             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4164             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4165
4166             if(type_cell->cell_kind == aioc__undefined)
4167                 continue;
4168
4169             presence_index++;
4170             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4171                 result.type_descriptor = type_cell->type_descriptor;
4172                 result.presence_index = presence_index;
4173                 break;
4174             }
4175         }
4176
4177         return result;
4178 }
4179
4180 static int
4181 memb_criticality_constraint_113(const asn_TYPE_descriptor_t *td, const void *sptr,
4182                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4183
4184         if(!sptr) {
4185                 ASN__CTFAIL(app_key, td, sptr,
4186                         "%s: value not given (%s:%d)",
4187                         td->name, __FILE__, __LINE__);
4188                 return -1;
4189         }
4190
4191
4192         if(1 /* No applicable constraints whatsoever */) {
4193                 /* Nothing is here. See below */
4194         }
4195
4196         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4197 }
4198
4199 static asn_type_selector_result_t
4200 select_E2nodeConfigurationUpdate_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4201         asn_type_selector_result_t result = {0, 0};
4202         const asn_ioc_set_t *itable = asn_IOS_E2nodeConfigurationUpdate_IEs_1;
4203         size_t constraining_column = 0; /* &id */
4204         size_t for_column = 2; /* &Value */
4205         size_t row, presence_index = 0;
4206         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeConfigurationUpdate_IEs, id));
4207
4208         for(row=0; row < itable->rows_count; row++) {
4209             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4210             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4211
4212             if(type_cell->cell_kind == aioc__undefined)
4213                 continue;
4214
4215             presence_index++;
4216             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4217                 result.type_descriptor = type_cell->type_descriptor;
4218                 result.presence_index = presence_index;
4219                 break;
4220             }
4221         }
4222
4223         return result;
4224 }
4225
4226 static int
4227 memb_value_constraint_113(const asn_TYPE_descriptor_t *td, const void *sptr,
4228                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4229
4230         if(!sptr) {
4231                 ASN__CTFAIL(app_key, td, sptr,
4232                         "%s: value not given (%s:%d)",
4233                         td->name, __FILE__, __LINE__);
4234                 return -1;
4235         }
4236
4237
4238         if(1 /* No applicable constraints whatsoever */) {
4239                 /* Nothing is here. See below */
4240         }
4241
4242         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4243 }
4244
4245 static int
4246 memb_id_constraint_117(const asn_TYPE_descriptor_t *td, const void *sptr,
4247                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4248         long value;
4249
4250         if(!sptr) {
4251                 ASN__CTFAIL(app_key, td, sptr,
4252                         "%s: value not given (%s:%d)",
4253                         td->name, __FILE__, __LINE__);
4254                 return -1;
4255         }
4256
4257         value = *(const long *)sptr;
4258
4259         if((value >= 0 && value <= 65535)) {
4260                 /* Constraint check succeeded */
4261                 return 0;
4262         } else {
4263                 ASN__CTFAIL(app_key, td, sptr,
4264                         "%s: constraint failed (%s:%d)",
4265                         td->name, __FILE__, __LINE__);
4266                 return -1;
4267         }
4268 }
4269
4270 static asn_type_selector_result_t
4271 select_E2nodeConfigurationUpdateAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4272         asn_type_selector_result_t result = {0, 0};
4273         const asn_ioc_set_t *itable = asn_IOS_E2nodeConfigurationUpdateAcknowledge_IEs_1;
4274         size_t constraining_column = 0; /* &id */
4275         size_t for_column = 1; /* &criticality */
4276         size_t row, presence_index = 0;
4277         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs, id));
4278
4279         for(row=0; row < itable->rows_count; row++) {
4280             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4281             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4282
4283             if(type_cell->cell_kind == aioc__undefined)
4284                 continue;
4285
4286             presence_index++;
4287             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4288                 result.type_descriptor = type_cell->type_descriptor;
4289                 result.presence_index = presence_index;
4290                 break;
4291             }
4292         }
4293
4294         return result;
4295 }
4296
4297 static int
4298 memb_criticality_constraint_117(const asn_TYPE_descriptor_t *td, const void *sptr,
4299                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4300
4301         if(!sptr) {
4302                 ASN__CTFAIL(app_key, td, sptr,
4303                         "%s: value not given (%s:%d)",
4304                         td->name, __FILE__, __LINE__);
4305                 return -1;
4306         }
4307
4308
4309         if(1 /* No applicable constraints whatsoever */) {
4310                 /* Nothing is here. See below */
4311         }
4312
4313         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4314 }
4315
4316 static asn_type_selector_result_t
4317 select_E2nodeConfigurationUpdateAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4318         asn_type_selector_result_t result = {0, 0};
4319         const asn_ioc_set_t *itable = asn_IOS_E2nodeConfigurationUpdateAcknowledge_IEs_1;
4320         size_t constraining_column = 0; /* &id */
4321         size_t for_column = 2; /* &Value */
4322         size_t row, presence_index = 0;
4323         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs, id));
4324
4325         for(row=0; row < itable->rows_count; row++) {
4326             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4327             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4328
4329             if(type_cell->cell_kind == aioc__undefined)
4330                 continue;
4331
4332             presence_index++;
4333             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4334                 result.type_descriptor = type_cell->type_descriptor;
4335                 result.presence_index = presence_index;
4336                 break;
4337             }
4338         }
4339
4340         return result;
4341 }
4342
4343 static int
4344 memb_value_constraint_117(const asn_TYPE_descriptor_t *td, const void *sptr,
4345                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4346
4347         if(!sptr) {
4348                 ASN__CTFAIL(app_key, td, sptr,
4349                         "%s: value not given (%s:%d)",
4350                         td->name, __FILE__, __LINE__);
4351                 return -1;
4352         }
4353
4354
4355         if(1 /* No applicable constraints whatsoever */) {
4356                 /* Nothing is here. See below */
4357         }
4358
4359         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4360 }
4361
4362 static int
4363 memb_id_constraint_121(const asn_TYPE_descriptor_t *td, const void *sptr,
4364                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4365         long value;
4366
4367         if(!sptr) {
4368                 ASN__CTFAIL(app_key, td, sptr,
4369                         "%s: value not given (%s:%d)",
4370                         td->name, __FILE__, __LINE__);
4371                 return -1;
4372         }
4373
4374         value = *(const long *)sptr;
4375
4376         if((value >= 0 && value <= 65535)) {
4377                 /* Constraint check succeeded */
4378                 return 0;
4379         } else {
4380                 ASN__CTFAIL(app_key, td, sptr,
4381                         "%s: constraint failed (%s:%d)",
4382                         td->name, __FILE__, __LINE__);
4383                 return -1;
4384         }
4385 }
4386
4387 static asn_type_selector_result_t
4388 select_E2nodeConfigurationUpdateFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4389         asn_type_selector_result_t result = {0, 0};
4390         const asn_ioc_set_t *itable = asn_IOS_E2nodeConfigurationUpdateFailure_IEs_1;
4391         size_t constraining_column = 0; /* &id */
4392         size_t for_column = 1; /* &criticality */
4393         size_t row, presence_index = 0;
4394         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeConfigurationUpdateFailure_IEs, id));
4395
4396         for(row=0; row < itable->rows_count; row++) {
4397             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4398             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4399
4400             if(type_cell->cell_kind == aioc__undefined)
4401                 continue;
4402
4403             presence_index++;
4404             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4405                 result.type_descriptor = type_cell->type_descriptor;
4406                 result.presence_index = presence_index;
4407                 break;
4408             }
4409         }
4410
4411         return result;
4412 }
4413
4414 static int
4415 memb_criticality_constraint_121(const asn_TYPE_descriptor_t *td, const void *sptr,
4416                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4417
4418         if(!sptr) {
4419                 ASN__CTFAIL(app_key, td, sptr,
4420                         "%s: value not given (%s:%d)",
4421                         td->name, __FILE__, __LINE__);
4422                 return -1;
4423         }
4424
4425
4426         if(1 /* No applicable constraints whatsoever */) {
4427                 /* Nothing is here. See below */
4428         }
4429
4430         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4431 }
4432
4433 static asn_type_selector_result_t
4434 select_E2nodeConfigurationUpdateFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4435         asn_type_selector_result_t result = {0, 0};
4436         const asn_ioc_set_t *itable = asn_IOS_E2nodeConfigurationUpdateFailure_IEs_1;
4437         size_t constraining_column = 0; /* &id */
4438         size_t for_column = 2; /* &Value */
4439         size_t row, presence_index = 0;
4440         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2nodeConfigurationUpdateFailure_IEs, id));
4441
4442         for(row=0; row < itable->rows_count; row++) {
4443             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4444             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4445
4446             if(type_cell->cell_kind == aioc__undefined)
4447                 continue;
4448
4449             presence_index++;
4450             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4451                 result.type_descriptor = type_cell->type_descriptor;
4452                 result.presence_index = presence_index;
4453                 break;
4454             }
4455         }
4456
4457         return result;
4458 }
4459
4460 static int
4461 memb_value_constraint_121(const asn_TYPE_descriptor_t *td, const void *sptr,
4462                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4463
4464         if(!sptr) {
4465                 ASN__CTFAIL(app_key, td, sptr,
4466                         "%s: value not given (%s:%d)",
4467                         td->name, __FILE__, __LINE__);
4468                 return -1;
4469         }
4470
4471
4472         if(1 /* No applicable constraints whatsoever */) {
4473                 /* Nothing is here. See below */
4474         }
4475
4476         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4477 }
4478
4479 static int
4480 memb_id_constraint_125(const asn_TYPE_descriptor_t *td, const void *sptr,
4481                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4482         long value;
4483
4484         if(!sptr) {
4485                 ASN__CTFAIL(app_key, td, sptr,
4486                         "%s: value not given (%s:%d)",
4487                         td->name, __FILE__, __LINE__);
4488                 return -1;
4489         }
4490
4491         value = *(const long *)sptr;
4492
4493         if((value >= 0 && value <= 65535)) {
4494                 /* Constraint check succeeded */
4495                 return 0;
4496         } else {
4497                 ASN__CTFAIL(app_key, td, sptr,
4498                         "%s: constraint failed (%s:%d)",
4499                         td->name, __FILE__, __LINE__);
4500                 return -1;
4501         }
4502 }
4503
4504 static asn_type_selector_result_t
4505 select_ResetRequestIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4506         asn_type_selector_result_t result = {0, 0};
4507         const asn_ioc_set_t *itable = asn_IOS_ResetRequestIEs_1;
4508         size_t constraining_column = 0; /* &id */
4509         size_t for_column = 1; /* &criticality */
4510         size_t row, presence_index = 0;
4511         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetRequestIEs, id));
4512
4513         for(row=0; row < itable->rows_count; row++) {
4514             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4515             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4516
4517             if(type_cell->cell_kind == aioc__undefined)
4518                 continue;
4519
4520             presence_index++;
4521             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4522                 result.type_descriptor = type_cell->type_descriptor;
4523                 result.presence_index = presence_index;
4524                 break;
4525             }
4526         }
4527
4528         return result;
4529 }
4530
4531 static int
4532 memb_criticality_constraint_125(const asn_TYPE_descriptor_t *td, const void *sptr,
4533                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4534
4535         if(!sptr) {
4536                 ASN__CTFAIL(app_key, td, sptr,
4537                         "%s: value not given (%s:%d)",
4538                         td->name, __FILE__, __LINE__);
4539                 return -1;
4540         }
4541
4542
4543         if(1 /* No applicable constraints whatsoever */) {
4544                 /* Nothing is here. See below */
4545         }
4546
4547         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4548 }
4549
4550 static asn_type_selector_result_t
4551 select_ResetRequestIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4552         asn_type_selector_result_t result = {0, 0};
4553         const asn_ioc_set_t *itable = asn_IOS_ResetRequestIEs_1;
4554         size_t constraining_column = 0; /* &id */
4555         size_t for_column = 2; /* &Value */
4556         size_t row, presence_index = 0;
4557         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetRequestIEs, id));
4558
4559         for(row=0; row < itable->rows_count; row++) {
4560             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4561             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4562
4563             if(type_cell->cell_kind == aioc__undefined)
4564                 continue;
4565
4566             presence_index++;
4567             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4568                 result.type_descriptor = type_cell->type_descriptor;
4569                 result.presence_index = presence_index;
4570                 break;
4571             }
4572         }
4573
4574         return result;
4575 }
4576
4577 static int
4578 memb_value_constraint_125(const asn_TYPE_descriptor_t *td, const void *sptr,
4579                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4580
4581         if(!sptr) {
4582                 ASN__CTFAIL(app_key, td, sptr,
4583                         "%s: value not given (%s:%d)",
4584                         td->name, __FILE__, __LINE__);
4585                 return -1;
4586         }
4587
4588
4589         if(1 /* No applicable constraints whatsoever */) {
4590                 /* Nothing is here. See below */
4591         }
4592
4593         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4594 }
4595
4596 static int
4597 memb_id_constraint_129(const asn_TYPE_descriptor_t *td, const void *sptr,
4598                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4599         long value;
4600
4601         if(!sptr) {
4602                 ASN__CTFAIL(app_key, td, sptr,
4603                         "%s: value not given (%s:%d)",
4604                         td->name, __FILE__, __LINE__);
4605                 return -1;
4606         }
4607
4608         value = *(const long *)sptr;
4609
4610         if((value >= 0 && value <= 65535)) {
4611                 /* Constraint check succeeded */
4612                 return 0;
4613         } else {
4614                 ASN__CTFAIL(app_key, td, sptr,
4615                         "%s: constraint failed (%s:%d)",
4616                         td->name, __FILE__, __LINE__);
4617                 return -1;
4618         }
4619 }
4620
4621 static asn_type_selector_result_t
4622 select_ResetResponseIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4623         asn_type_selector_result_t result = {0, 0};
4624         const asn_ioc_set_t *itable = asn_IOS_ResetResponseIEs_1;
4625         size_t constraining_column = 0; /* &id */
4626         size_t for_column = 1; /* &criticality */
4627         size_t row, presence_index = 0;
4628         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetResponseIEs, id));
4629
4630         for(row=0; row < itable->rows_count; row++) {
4631             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4632             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4633
4634             if(type_cell->cell_kind == aioc__undefined)
4635                 continue;
4636
4637             presence_index++;
4638             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4639                 result.type_descriptor = type_cell->type_descriptor;
4640                 result.presence_index = presence_index;
4641                 break;
4642             }
4643         }
4644
4645         return result;
4646 }
4647
4648 static int
4649 memb_criticality_constraint_129(const asn_TYPE_descriptor_t *td, const void *sptr,
4650                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4651
4652         if(!sptr) {
4653                 ASN__CTFAIL(app_key, td, sptr,
4654                         "%s: value not given (%s:%d)",
4655                         td->name, __FILE__, __LINE__);
4656                 return -1;
4657         }
4658
4659
4660         if(1 /* No applicable constraints whatsoever */) {
4661                 /* Nothing is here. See below */
4662         }
4663
4664         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4665 }
4666
4667 static asn_type_selector_result_t
4668 select_ResetResponseIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4669         asn_type_selector_result_t result = {0, 0};
4670         const asn_ioc_set_t *itable = asn_IOS_ResetResponseIEs_1;
4671         size_t constraining_column = 0; /* &id */
4672         size_t for_column = 2; /* &Value */
4673         size_t row, presence_index = 0;
4674         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetResponseIEs, id));
4675
4676         for(row=0; row < itable->rows_count; row++) {
4677             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4678             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4679
4680             if(type_cell->cell_kind == aioc__undefined)
4681                 continue;
4682
4683             presence_index++;
4684             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4685                 result.type_descriptor = type_cell->type_descriptor;
4686                 result.presence_index = presence_index;
4687                 break;
4688             }
4689         }
4690
4691         return result;
4692 }
4693
4694 static int
4695 memb_value_constraint_129(const asn_TYPE_descriptor_t *td, const void *sptr,
4696                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4697
4698         if(!sptr) {
4699                 ASN__CTFAIL(app_key, td, sptr,
4700                         "%s: value not given (%s:%d)",
4701                         td->name, __FILE__, __LINE__);
4702                 return -1;
4703         }
4704
4705
4706         if(1 /* No applicable constraints whatsoever */) {
4707                 /* Nothing is here. See below */
4708         }
4709
4710         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4711 }
4712
4713 static int
4714 memb_id_constraint_133(const asn_TYPE_descriptor_t *td, const void *sptr,
4715                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4716         long value;
4717
4718         if(!sptr) {
4719                 ASN__CTFAIL(app_key, td, sptr,
4720                         "%s: value not given (%s:%d)",
4721                         td->name, __FILE__, __LINE__);
4722                 return -1;
4723         }
4724
4725         value = *(const long *)sptr;
4726
4727         if((value >= 0 && value <= 65535)) {
4728                 /* Constraint check succeeded */
4729                 return 0;
4730         } else {
4731                 ASN__CTFAIL(app_key, td, sptr,
4732                         "%s: constraint failed (%s:%d)",
4733                         td->name, __FILE__, __LINE__);
4734                 return -1;
4735         }
4736 }
4737
4738 static asn_type_selector_result_t
4739 select_RICserviceUpdate_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4740         asn_type_selector_result_t result = {0, 0};
4741         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdate_IEs_1;
4742         size_t constraining_column = 0; /* &id */
4743         size_t for_column = 1; /* &criticality */
4744         size_t row, presence_index = 0;
4745         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdate_IEs, id));
4746
4747         for(row=0; row < itable->rows_count; row++) {
4748             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4749             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4750
4751             if(type_cell->cell_kind == aioc__undefined)
4752                 continue;
4753
4754             presence_index++;
4755             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4756                 result.type_descriptor = type_cell->type_descriptor;
4757                 result.presence_index = presence_index;
4758                 break;
4759             }
4760         }
4761
4762         return result;
4763 }
4764
4765 static int
4766 memb_criticality_constraint_133(const asn_TYPE_descriptor_t *td, const void *sptr,
4767                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4768
4769         if(!sptr) {
4770                 ASN__CTFAIL(app_key, td, sptr,
4771                         "%s: value not given (%s:%d)",
4772                         td->name, __FILE__, __LINE__);
4773                 return -1;
4774         }
4775
4776
4777         if(1 /* No applicable constraints whatsoever */) {
4778                 /* Nothing is here. See below */
4779         }
4780
4781         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4782 }
4783
4784 static asn_type_selector_result_t
4785 select_RICserviceUpdate_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4786         asn_type_selector_result_t result = {0, 0};
4787         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdate_IEs_1;
4788         size_t constraining_column = 0; /* &id */
4789         size_t for_column = 2; /* &Value */
4790         size_t row, presence_index = 0;
4791         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdate_IEs, id));
4792         const int indexToPresence[4] = {
4793                 RICserviceUpdate_IEs__value_PR_NOTHING,
4794                 RICserviceUpdate_IEs__value_PR_RANfunctions_List,
4795                 RICserviceUpdate_IEs__value_PR_RANfunctions_List,
4796                 RICserviceUpdate_IEs__value_PR_RANfunctionsID_List
4797         };
4798
4799         for(row=0; row < itable->rows_count; row++) {
4800             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4801             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4802
4803             if(type_cell->cell_kind == aioc__undefined)
4804                 continue;
4805
4806             presence_index++;
4807             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4808                 result.type_descriptor = type_cell->type_descriptor;
4809                 result.presence_index = indexToPresence[presence_index];
4810                 break;
4811             }
4812         }
4813
4814         return result;
4815 }
4816
4817 static int
4818 memb_value_constraint_133(const asn_TYPE_descriptor_t *td, const void *sptr,
4819                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4820
4821         if(!sptr) {
4822                 ASN__CTFAIL(app_key, td, sptr,
4823                         "%s: value not given (%s:%d)",
4824                         td->name, __FILE__, __LINE__);
4825                 return -1;
4826         }
4827
4828
4829         if(1 /* No applicable constraints whatsoever */) {
4830                 /* Nothing is here. See below */
4831         }
4832
4833         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4834 }
4835
4836 static int
4837 memb_id_constraint_137(const asn_TYPE_descriptor_t *td, const void *sptr,
4838                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4839         long value;
4840
4841         if(!sptr) {
4842                 ASN__CTFAIL(app_key, td, sptr,
4843                         "%s: value not given (%s:%d)",
4844                         td->name, __FILE__, __LINE__);
4845                 return -1;
4846         }
4847
4848         value = *(const long *)sptr;
4849
4850         if((value >= 0 && value <= 65535)) {
4851                 /* Constraint check succeeded */
4852                 return 0;
4853         } else {
4854                 ASN__CTFAIL(app_key, td, sptr,
4855                         "%s: constraint failed (%s:%d)",
4856                         td->name, __FILE__, __LINE__);
4857                 return -1;
4858         }
4859 }
4860
4861 static asn_type_selector_result_t
4862 select_RICserviceUpdateAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4863         asn_type_selector_result_t result = {0, 0};
4864         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateAcknowledge_IEs_1;
4865         size_t constraining_column = 0; /* &id */
4866         size_t for_column = 1; /* &criticality */
4867         size_t row, presence_index = 0;
4868         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateAcknowledge_IEs, id));
4869
4870         for(row=0; row < itable->rows_count; row++) {
4871             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4872             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4873
4874             if(type_cell->cell_kind == aioc__undefined)
4875                 continue;
4876
4877             presence_index++;
4878             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4879                 result.type_descriptor = type_cell->type_descriptor;
4880                 result.presence_index = presence_index;
4881                 break;
4882             }
4883         }
4884
4885         return result;
4886 }
4887
4888 static int
4889 memb_criticality_constraint_137(const asn_TYPE_descriptor_t *td, const void *sptr,
4890                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4891
4892         if(!sptr) {
4893                 ASN__CTFAIL(app_key, td, sptr,
4894                         "%s: value not given (%s:%d)",
4895                         td->name, __FILE__, __LINE__);
4896                 return -1;
4897         }
4898
4899
4900         if(1 /* No applicable constraints whatsoever */) {
4901                 /* Nothing is here. See below */
4902         }
4903
4904         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4905 }
4906
4907 static asn_type_selector_result_t
4908 select_RICserviceUpdateAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4909         asn_type_selector_result_t result = {0, 0};
4910         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateAcknowledge_IEs_1;
4911         size_t constraining_column = 0; /* &id */
4912         size_t for_column = 2; /* &Value */
4913         size_t row, presence_index = 0;
4914         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateAcknowledge_IEs, id));
4915
4916         for(row=0; row < itable->rows_count; row++) {
4917             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4918             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4919
4920             if(type_cell->cell_kind == aioc__undefined)
4921                 continue;
4922
4923             presence_index++;
4924             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4925                 result.type_descriptor = type_cell->type_descriptor;
4926                 result.presence_index = presence_index;
4927                 break;
4928             }
4929         }
4930
4931         return result;
4932 }
4933
4934 static int
4935 memb_value_constraint_137(const asn_TYPE_descriptor_t *td, const void *sptr,
4936                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4937
4938         if(!sptr) {
4939                 ASN__CTFAIL(app_key, td, sptr,
4940                         "%s: value not given (%s:%d)",
4941                         td->name, __FILE__, __LINE__);
4942                 return -1;
4943         }
4944
4945
4946         if(1 /* No applicable constraints whatsoever */) {
4947                 /* Nothing is here. See below */
4948         }
4949
4950         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
4951 }
4952
4953 static int
4954 memb_id_constraint_141(const asn_TYPE_descriptor_t *td, const void *sptr,
4955                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
4956         long value;
4957
4958         if(!sptr) {
4959                 ASN__CTFAIL(app_key, td, sptr,
4960                         "%s: value not given (%s:%d)",
4961                         td->name, __FILE__, __LINE__);
4962                 return -1;
4963         }
4964
4965         value = *(const long *)sptr;
4966
4967         if((value >= 0 && value <= 65535)) {
4968                 /* Constraint check succeeded */
4969                 return 0;
4970         } else {
4971                 ASN__CTFAIL(app_key, td, sptr,
4972                         "%s: constraint failed (%s:%d)",
4973                         td->name, __FILE__, __LINE__);
4974                 return -1;
4975         }
4976 }
4977
4978 static asn_type_selector_result_t
4979 select_RICserviceUpdateFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
4980         asn_type_selector_result_t result = {0, 0};
4981         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateFailure_IEs_1;
4982         size_t constraining_column = 0; /* &id */
4983         size_t for_column = 1; /* &criticality */
4984         size_t row, presence_index = 0;
4985         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateFailure_IEs, id));
4986
4987         for(row=0; row < itable->rows_count; row++) {
4988             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
4989             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
4990
4991             if(type_cell->cell_kind == aioc__undefined)
4992                 continue;
4993
4994             presence_index++;
4995             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
4996                 result.type_descriptor = type_cell->type_descriptor;
4997                 result.presence_index = presence_index;
4998                 break;
4999             }
5000         }
5001
5002         return result;
5003 }
5004
5005 static int
5006 memb_criticality_constraint_141(const asn_TYPE_descriptor_t *td, const void *sptr,
5007                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
5008
5009         if(!sptr) {
5010                 ASN__CTFAIL(app_key, td, sptr,
5011                         "%s: value not given (%s:%d)",
5012                         td->name, __FILE__, __LINE__);
5013                 return -1;
5014         }
5015
5016
5017         if(1 /* No applicable constraints whatsoever */) {
5018                 /* Nothing is here. See below */
5019         }
5020
5021         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
5022 }
5023
5024 static asn_type_selector_result_t
5025 select_RICserviceUpdateFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
5026         asn_type_selector_result_t result = {0, 0};
5027         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateFailure_IEs_1;
5028         size_t constraining_column = 0; /* &id */
5029         size_t for_column = 2; /* &Value */
5030         size_t row, presence_index = 0;
5031         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateFailure_IEs, id));
5032
5033         for(row=0; row < itable->rows_count; row++) {
5034             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
5035             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
5036
5037             if(type_cell->cell_kind == aioc__undefined)
5038                 continue;
5039
5040             presence_index++;
5041             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
5042                 result.type_descriptor = type_cell->type_descriptor;
5043                 result.presence_index = presence_index;
5044                 break;
5045             }
5046         }
5047
5048         return result;
5049 }
5050
5051 static int
5052 memb_value_constraint_141(const asn_TYPE_descriptor_t *td, const void *sptr,
5053                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
5054
5055         if(!sptr) {
5056                 ASN__CTFAIL(app_key, td, sptr,
5057                         "%s: value not given (%s:%d)",
5058                         td->name, __FILE__, __LINE__);
5059                 return -1;
5060         }
5061
5062
5063         if(1 /* No applicable constraints whatsoever */) {
5064                 /* Nothing is here. See below */
5065         }
5066
5067         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
5068 }
5069
5070 static int
5071 memb_id_constraint_145(const asn_TYPE_descriptor_t *td, const void *sptr,
5072                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
5073         long value;
5074
5075         if(!sptr) {
5076                 ASN__CTFAIL(app_key, td, sptr,
5077                         "%s: value not given (%s:%d)",
5078                         td->name, __FILE__, __LINE__);
5079                 return -1;
5080         }
5081
5082         value = *(const long *)sptr;
5083
5084         if((value >= 0 && value <= 65535)) {
5085                 /* Constraint check succeeded */
5086                 return 0;
5087         } else {
5088                 ASN__CTFAIL(app_key, td, sptr,
5089                         "%s: constraint failed (%s:%d)",
5090                         td->name, __FILE__, __LINE__);
5091                 return -1;
5092         }
5093 }
5094
5095 static asn_type_selector_result_t
5096 select_RICserviceQuery_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
5097         asn_type_selector_result_t result = {0, 0};
5098         const asn_ioc_set_t *itable = asn_IOS_RICserviceQuery_IEs_1;
5099         size_t constraining_column = 0; /* &id */
5100         size_t for_column = 1; /* &criticality */
5101         size_t row, presence_index = 0;
5102         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceQuery_IEs, id));
5103
5104         for(row=0; row < itable->rows_count; row++) {
5105             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
5106             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
5107
5108             if(type_cell->cell_kind == aioc__undefined)
5109                 continue;
5110
5111             presence_index++;
5112             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
5113                 result.type_descriptor = type_cell->type_descriptor;
5114                 result.presence_index = presence_index;
5115                 break;
5116             }
5117         }
5118
5119         return result;
5120 }
5121
5122 static int
5123 memb_criticality_constraint_145(const asn_TYPE_descriptor_t *td, const void *sptr,
5124                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
5125
5126         if(!sptr) {
5127                 ASN__CTFAIL(app_key, td, sptr,
5128                         "%s: value not given (%s:%d)",
5129                         td->name, __FILE__, __LINE__);
5130                 return -1;
5131         }
5132
5133
5134         if(1 /* No applicable constraints whatsoever */) {
5135                 /* Nothing is here. See below */
5136         }
5137
5138         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
5139 }
5140
5141 static asn_type_selector_result_t
5142 select_RICserviceQuery_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
5143         asn_type_selector_result_t result = {0, 0};
5144         const asn_ioc_set_t *itable = asn_IOS_RICserviceQuery_IEs_1;
5145         size_t constraining_column = 0; /* &id */
5146         size_t for_column = 2; /* &Value */
5147         size_t row, presence_index = 0;
5148         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceQuery_IEs, id));
5149
5150         for(row=0; row < itable->rows_count; row++) {
5151             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
5152             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
5153
5154             if(type_cell->cell_kind == aioc__undefined)
5155                 continue;
5156
5157             presence_index++;
5158             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
5159                 result.type_descriptor = type_cell->type_descriptor;
5160                 result.presence_index = presence_index;
5161                 break;
5162             }
5163         }
5164
5165         return result;
5166 }
5167
5168 static int
5169 memb_value_constraint_145(const asn_TYPE_descriptor_t *td, const void *sptr,
5170                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
5171
5172         if(!sptr) {
5173                 ASN__CTFAIL(app_key, td, sptr,
5174                         "%s: value not given (%s:%d)",
5175                         td->name, __FILE__, __LINE__);
5176                 return -1;
5177         }
5178
5179
5180         if(1 /* No applicable constraints whatsoever */) {
5181                 /* Nothing is here. See below */
5182         }
5183
5184         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
5185 }
5186
5187 static asn_per_constraints_t asn_PER_memb_id_constr_2 CC_NOTUSED = {
5188         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5189         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5190         0, 0    /* No PER value map */
5191 };
5192 static asn_per_constraints_t asn_PER_memb_criticality_constr_3 CC_NOTUSED = {
5193         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5194         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5195         0, 0    /* No PER value map */
5196 };
5197 static asn_per_constraints_t asn_PER_memb_value_constr_4 CC_NOTUSED = {
5198         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5199         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5200         0, 0    /* No PER value map */
5201 };
5202 static asn_per_constraints_t asn_PER_memb_id_constr_6 CC_NOTUSED = {
5203         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5204         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5205         0, 0    /* No PER value map */
5206 };
5207 static asn_per_constraints_t asn_PER_memb_criticality_constr_7 CC_NOTUSED = {
5208         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5209         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5210         0, 0    /* No PER value map */
5211 };
5212 static asn_per_constraints_t asn_PER_memb_value_constr_8 CC_NOTUSED = {
5213         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5214         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5215         0, 0    /* No PER value map */
5216 };
5217 static asn_per_constraints_t asn_PER_memb_id_constr_10 CC_NOTUSED = {
5218         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5219         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5220         0, 0    /* No PER value map */
5221 };
5222 static asn_per_constraints_t asn_PER_memb_criticality_constr_11 CC_NOTUSED = {
5223         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5224         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5225         0, 0    /* No PER value map */
5226 };
5227 static asn_per_constraints_t asn_PER_memb_value_constr_12 CC_NOTUSED = {
5228         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5229         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5230         0, 0    /* No PER value map */
5231 };
5232 static asn_per_constraints_t asn_PER_memb_id_constr_14 CC_NOTUSED = {
5233         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5234         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5235         0, 0    /* No PER value map */
5236 };
5237 static asn_per_constraints_t asn_PER_memb_criticality_constr_15 CC_NOTUSED = {
5238         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5239         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5240         0, 0    /* No PER value map */
5241 };
5242 static asn_per_constraints_t asn_PER_memb_value_constr_16 CC_NOTUSED = {
5243         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5244         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5245         0, 0    /* No PER value map */
5246 };
5247 static asn_per_constraints_t asn_PER_memb_id_constr_18 CC_NOTUSED = {
5248         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5249         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5250         0, 0    /* No PER value map */
5251 };
5252 static asn_per_constraints_t asn_PER_memb_criticality_constr_19 CC_NOTUSED = {
5253         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5254         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5255         0, 0    /* No PER value map */
5256 };
5257 static asn_per_constraints_t asn_PER_memb_value_constr_20 CC_NOTUSED = {
5258         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5259         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5260         0, 0    /* No PER value map */
5261 };
5262 static asn_per_constraints_t asn_PER_memb_id_constr_22 CC_NOTUSED = {
5263         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5264         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5265         0, 0    /* No PER value map */
5266 };
5267 static asn_per_constraints_t asn_PER_memb_criticality_constr_23 CC_NOTUSED = {
5268         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5269         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5270         0, 0    /* No PER value map */
5271 };
5272 static asn_per_constraints_t asn_PER_memb_value_constr_24 CC_NOTUSED = {
5273         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5274         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5275         0, 0    /* No PER value map */
5276 };
5277 static asn_per_constraints_t asn_PER_memb_id_constr_26 CC_NOTUSED = {
5278         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5279         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5280         0, 0    /* No PER value map */
5281 };
5282 static asn_per_constraints_t asn_PER_memb_criticality_constr_27 CC_NOTUSED = {
5283         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5284         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5285         0, 0    /* No PER value map */
5286 };
5287 static asn_per_constraints_t asn_PER_memb_value_constr_28 CC_NOTUSED = {
5288         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5289         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5290         0, 0    /* No PER value map */
5291 };
5292 static asn_per_constraints_t asn_PER_memb_id_constr_30 CC_NOTUSED = {
5293         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5294         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5295         0, 0    /* No PER value map */
5296 };
5297 static asn_per_constraints_t asn_PER_memb_criticality_constr_31 CC_NOTUSED = {
5298         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5299         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5300         0, 0    /* No PER value map */
5301 };
5302 static asn_per_constraints_t asn_PER_memb_value_constr_32 CC_NOTUSED = {
5303         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5304         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5305         0, 0    /* No PER value map */
5306 };
5307 static asn_per_constraints_t asn_PER_memb_id_constr_34 CC_NOTUSED = {
5308         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5309         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5310         0, 0    /* No PER value map */
5311 };
5312 static asn_per_constraints_t asn_PER_memb_criticality_constr_35 CC_NOTUSED = {
5313         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5314         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5315         0, 0    /* No PER value map */
5316 };
5317 static asn_per_constraints_t asn_PER_memb_value_constr_36 CC_NOTUSED = {
5318         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5319         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5320         0, 0    /* No PER value map */
5321 };
5322 static asn_per_constraints_t asn_PER_memb_id_constr_38 CC_NOTUSED = {
5323         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5324         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5325         0, 0    /* No PER value map */
5326 };
5327 static asn_per_constraints_t asn_PER_memb_criticality_constr_39 CC_NOTUSED = {
5328         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5329         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5330         0, 0    /* No PER value map */
5331 };
5332 static asn_per_constraints_t asn_PER_memb_value_constr_40 CC_NOTUSED = {
5333         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5334         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5335         0, 0    /* No PER value map */
5336 };
5337 static asn_per_constraints_t asn_PER_memb_id_constr_42 CC_NOTUSED = {
5338         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5339         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5340         0, 0    /* No PER value map */
5341 };
5342 static asn_per_constraints_t asn_PER_memb_criticality_constr_43 CC_NOTUSED = {
5343         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5344         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5345         0, 0    /* No PER value map */
5346 };
5347 static asn_per_constraints_t asn_PER_memb_value_constr_44 CC_NOTUSED = {
5348         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5349         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5350         0, 0    /* No PER value map */
5351 };
5352 static asn_per_constraints_t asn_PER_memb_id_constr_46 CC_NOTUSED = {
5353         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5354         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5355         0, 0    /* No PER value map */
5356 };
5357 static asn_per_constraints_t asn_PER_memb_criticality_constr_47 CC_NOTUSED = {
5358         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5359         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5360         0, 0    /* No PER value map */
5361 };
5362 static asn_per_constraints_t asn_PER_memb_value_constr_48 CC_NOTUSED = {
5363         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5364         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5365         0, 0    /* No PER value map */
5366 };
5367 static asn_per_constraints_t asn_PER_memb_id_constr_50 CC_NOTUSED = {
5368         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5369         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5370         0, 0    /* No PER value map */
5371 };
5372 static asn_per_constraints_t asn_PER_memb_criticality_constr_51 CC_NOTUSED = {
5373         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5374         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5375         0, 0    /* No PER value map */
5376 };
5377 static asn_per_constraints_t asn_PER_memb_value_constr_52 CC_NOTUSED = {
5378         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5379         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5380         0, 0    /* No PER value map */
5381 };
5382 static asn_per_constraints_t asn_PER_memb_id_constr_54 CC_NOTUSED = {
5383         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5384         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5385         0, 0    /* No PER value map */
5386 };
5387 static asn_per_constraints_t asn_PER_memb_criticality_constr_55 CC_NOTUSED = {
5388         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5389         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5390         0, 0    /* No PER value map */
5391 };
5392 static asn_per_constraints_t asn_PER_memb_value_constr_56 CC_NOTUSED = {
5393         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5394         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5395         0, 0    /* No PER value map */
5396 };
5397 static asn_per_constraints_t asn_PER_memb_id_constr_58 CC_NOTUSED = {
5398         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5399         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5400         0, 0    /* No PER value map */
5401 };
5402 static asn_per_constraints_t asn_PER_memb_criticality_constr_59 CC_NOTUSED = {
5403         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5404         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5405         0, 0    /* No PER value map */
5406 };
5407 static asn_per_constraints_t asn_PER_memb_value_constr_60 CC_NOTUSED = {
5408         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5409         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5410         0, 0    /* No PER value map */
5411 };
5412 static asn_per_constraints_t asn_PER_memb_id_constr_62 CC_NOTUSED = {
5413         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5414         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5415         0, 0    /* No PER value map */
5416 };
5417 static asn_per_constraints_t asn_PER_memb_criticality_constr_63 CC_NOTUSED = {
5418         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5419         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5420         0, 0    /* No PER value map */
5421 };
5422 static asn_per_constraints_t asn_PER_memb_value_constr_64 CC_NOTUSED = {
5423         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5424         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5425         0, 0    /* No PER value map */
5426 };
5427 static asn_per_constraints_t asn_PER_memb_id_constr_66 CC_NOTUSED = {
5428         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5429         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5430         0, 0    /* No PER value map */
5431 };
5432 static asn_per_constraints_t asn_PER_memb_criticality_constr_67 CC_NOTUSED = {
5433         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5434         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5435         0, 0    /* No PER value map */
5436 };
5437 static asn_per_constraints_t asn_PER_memb_value_constr_68 CC_NOTUSED = {
5438         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5439         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5440         0, 0    /* No PER value map */
5441 };
5442 static asn_per_constraints_t asn_PER_memb_id_constr_70 CC_NOTUSED = {
5443         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5444         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5445         0, 0    /* No PER value map */
5446 };
5447 static asn_per_constraints_t asn_PER_memb_criticality_constr_71 CC_NOTUSED = {
5448         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5449         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5450         0, 0    /* No PER value map */
5451 };
5452 static asn_per_constraints_t asn_PER_memb_value_constr_72 CC_NOTUSED = {
5453         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5454         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5455         0, 0    /* No PER value map */
5456 };
5457 static asn_per_constraints_t asn_PER_memb_id_constr_74 CC_NOTUSED = {
5458         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5459         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5460         0, 0    /* No PER value map */
5461 };
5462 static asn_per_constraints_t asn_PER_memb_criticality_constr_75 CC_NOTUSED = {
5463         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5464         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5465         0, 0    /* No PER value map */
5466 };
5467 static asn_per_constraints_t asn_PER_memb_value_constr_76 CC_NOTUSED = {
5468         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5469         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5470         0, 0    /* No PER value map */
5471 };
5472 static asn_per_constraints_t asn_PER_memb_id_constr_78 CC_NOTUSED = {
5473         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5474         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5475         0, 0    /* No PER value map */
5476 };
5477 static asn_per_constraints_t asn_PER_memb_criticality_constr_79 CC_NOTUSED = {
5478         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5479         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5480         0, 0    /* No PER value map */
5481 };
5482 static asn_per_constraints_t asn_PER_memb_value_constr_80 CC_NOTUSED = {
5483         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5484         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5485         0, 0    /* No PER value map */
5486 };
5487 static asn_per_constraints_t asn_PER_memb_id_constr_82 CC_NOTUSED = {
5488         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5489         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5490         0, 0    /* No PER value map */
5491 };
5492 static asn_per_constraints_t asn_PER_memb_criticality_constr_83 CC_NOTUSED = {
5493         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5494         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5495         0, 0    /* No PER value map */
5496 };
5497 static asn_per_constraints_t asn_PER_memb_value_constr_84 CC_NOTUSED = {
5498         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5499         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5500         0, 0    /* No PER value map */
5501 };
5502 static asn_per_constraints_t asn_PER_memb_id_constr_86 CC_NOTUSED = {
5503         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5504         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5505         0, 0    /* No PER value map */
5506 };
5507 static asn_per_constraints_t asn_PER_memb_criticality_constr_87 CC_NOTUSED = {
5508         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5509         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5510         0, 0    /* No PER value map */
5511 };
5512 static asn_per_constraints_t asn_PER_memb_value_constr_88 CC_NOTUSED = {
5513         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5514         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5515         0, 0    /* No PER value map */
5516 };
5517 static asn_per_constraints_t asn_PER_memb_id_constr_90 CC_NOTUSED = {
5518         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5519         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5520         0, 0    /* No PER value map */
5521 };
5522 static asn_per_constraints_t asn_PER_memb_criticality_constr_91 CC_NOTUSED = {
5523         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5524         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5525         0, 0    /* No PER value map */
5526 };
5527 static asn_per_constraints_t asn_PER_memb_value_constr_92 CC_NOTUSED = {
5528         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5529         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5530         0, 0    /* No PER value map */
5531 };
5532 static asn_per_constraints_t asn_PER_memb_id_constr_94 CC_NOTUSED = {
5533         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5534         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5535         0, 0    /* No PER value map */
5536 };
5537 static asn_per_constraints_t asn_PER_memb_criticality_constr_95 CC_NOTUSED = {
5538         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5539         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5540         0, 0    /* No PER value map */
5541 };
5542 static asn_per_constraints_t asn_PER_memb_value_constr_96 CC_NOTUSED = {
5543         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5544         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5545         0, 0    /* No PER value map */
5546 };
5547 static asn_per_constraints_t asn_PER_memb_id_constr_98 CC_NOTUSED = {
5548         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5549         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5550         0, 0    /* No PER value map */
5551 };
5552 static asn_per_constraints_t asn_PER_memb_criticality_constr_99 CC_NOTUSED = {
5553         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5554         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5555         0, 0    /* No PER value map */
5556 };
5557 static asn_per_constraints_t asn_PER_memb_value_constr_100 CC_NOTUSED = {
5558         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5559         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5560         0, 0    /* No PER value map */
5561 };
5562 static asn_per_constraints_t asn_PER_memb_id_constr_102 CC_NOTUSED = {
5563         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5564         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5565         0, 0    /* No PER value map */
5566 };
5567 static asn_per_constraints_t asn_PER_memb_criticality_constr_103 CC_NOTUSED = {
5568         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5569         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5570         0, 0    /* No PER value map */
5571 };
5572 static asn_per_constraints_t asn_PER_memb_value_constr_104 CC_NOTUSED = {
5573         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5574         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5575         0, 0    /* No PER value map */
5576 };
5577 static asn_per_constraints_t asn_PER_memb_id_constr_106 CC_NOTUSED = {
5578         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5579         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5580         0, 0    /* No PER value map */
5581 };
5582 static asn_per_constraints_t asn_PER_memb_criticality_constr_107 CC_NOTUSED = {
5583         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5584         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5585         0, 0    /* No PER value map */
5586 };
5587 static asn_per_constraints_t asn_PER_memb_value_constr_108 CC_NOTUSED = {
5588         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5589         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5590         0, 0    /* No PER value map */
5591 };
5592 static asn_per_constraints_t asn_PER_memb_id_constr_110 CC_NOTUSED = {
5593         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5594         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5595         0, 0    /* No PER value map */
5596 };
5597 static asn_per_constraints_t asn_PER_memb_criticality_constr_111 CC_NOTUSED = {
5598         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5599         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5600         0, 0    /* No PER value map */
5601 };
5602 static asn_per_constraints_t asn_PER_memb_value_constr_112 CC_NOTUSED = {
5603         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5604         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5605         0, 0    /* No PER value map */
5606 };
5607 static asn_per_constraints_t asn_PER_memb_id_constr_114 CC_NOTUSED = {
5608         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5609         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5610         0, 0    /* No PER value map */
5611 };
5612 static asn_per_constraints_t asn_PER_memb_criticality_constr_115 CC_NOTUSED = {
5613         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5614         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5615         0, 0    /* No PER value map */
5616 };
5617 static asn_per_constraints_t asn_PER_memb_value_constr_116 CC_NOTUSED = {
5618         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5619         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5620         0, 0    /* No PER value map */
5621 };
5622 static asn_per_constraints_t asn_PER_memb_id_constr_118 CC_NOTUSED = {
5623         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5624         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5625         0, 0    /* No PER value map */
5626 };
5627 static asn_per_constraints_t asn_PER_memb_criticality_constr_119 CC_NOTUSED = {
5628         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5629         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5630         0, 0    /* No PER value map */
5631 };
5632 static asn_per_constraints_t asn_PER_memb_value_constr_120 CC_NOTUSED = {
5633         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5634         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5635         0, 0    /* No PER value map */
5636 };
5637 static asn_per_constraints_t asn_PER_memb_id_constr_122 CC_NOTUSED = {
5638         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5639         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5640         0, 0    /* No PER value map */
5641 };
5642 static asn_per_constraints_t asn_PER_memb_criticality_constr_123 CC_NOTUSED = {
5643         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5644         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5645         0, 0    /* No PER value map */
5646 };
5647 static asn_per_constraints_t asn_PER_memb_value_constr_124 CC_NOTUSED = {
5648         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5649         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5650         0, 0    /* No PER value map */
5651 };
5652 static asn_per_constraints_t asn_PER_memb_id_constr_126 CC_NOTUSED = {
5653         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5654         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5655         0, 0    /* No PER value map */
5656 };
5657 static asn_per_constraints_t asn_PER_memb_criticality_constr_127 CC_NOTUSED = {
5658         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5659         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5660         0, 0    /* No PER value map */
5661 };
5662 static asn_per_constraints_t asn_PER_memb_value_constr_128 CC_NOTUSED = {
5663         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5664         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5665         0, 0    /* No PER value map */
5666 };
5667 static asn_per_constraints_t asn_PER_memb_id_constr_130 CC_NOTUSED = {
5668         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5669         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5670         0, 0    /* No PER value map */
5671 };
5672 static asn_per_constraints_t asn_PER_memb_criticality_constr_131 CC_NOTUSED = {
5673         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5674         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5675         0, 0    /* No PER value map */
5676 };
5677 static asn_per_constraints_t asn_PER_memb_value_constr_132 CC_NOTUSED = {
5678         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5679         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5680         0, 0    /* No PER value map */
5681 };
5682 static asn_per_constraints_t asn_PER_memb_id_constr_134 CC_NOTUSED = {
5683         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5684         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5685         0, 0    /* No PER value map */
5686 };
5687 static asn_per_constraints_t asn_PER_memb_criticality_constr_135 CC_NOTUSED = {
5688         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5689         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5690         0, 0    /* No PER value map */
5691 };
5692 static asn_per_constraints_t asn_PER_memb_value_constr_136 CC_NOTUSED = {
5693         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5694         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5695         0, 0    /* No PER value map */
5696 };
5697 static asn_per_constraints_t asn_PER_memb_id_constr_138 CC_NOTUSED = {
5698         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5699         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5700         0, 0    /* No PER value map */
5701 };
5702 static asn_per_constraints_t asn_PER_memb_criticality_constr_139 CC_NOTUSED = {
5703         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5704         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5705         0, 0    /* No PER value map */
5706 };
5707 static asn_per_constraints_t asn_PER_memb_value_constr_140 CC_NOTUSED = {
5708         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5709         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5710         0, 0    /* No PER value map */
5711 };
5712 static asn_per_constraints_t asn_PER_memb_id_constr_142 CC_NOTUSED = {
5713         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5714         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5715         0, 0    /* No PER value map */
5716 };
5717 static asn_per_constraints_t asn_PER_memb_criticality_constr_143 CC_NOTUSED = {
5718         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5719         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5720         0, 0    /* No PER value map */
5721 };
5722 static asn_per_constraints_t asn_PER_memb_value_constr_144 CC_NOTUSED = {
5723         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5724         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5725         0, 0    /* No PER value map */
5726 };
5727 static asn_per_constraints_t asn_PER_memb_id_constr_146 CC_NOTUSED = {
5728         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
5729         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5730         0, 0    /* No PER value map */
5731 };
5732 static asn_per_constraints_t asn_PER_memb_criticality_constr_147 CC_NOTUSED = {
5733         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
5734         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5735         0, 0    /* No PER value map */
5736 };
5737 static asn_per_constraints_t asn_PER_memb_value_constr_148 CC_NOTUSED = {
5738         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5739         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
5740         0, 0    /* No PER value map */
5741 };
5742 static asn_TYPE_member_t asn_MBR_value_4[] = {
5743         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs__value, choice.RICaction_ToBeSetup_Item),
5744                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5745                 0,
5746                 &asn_DEF_RICaction_ToBeSetup_Item,
5747                 0,
5748                 { 0, 0, 0 },
5749                 0, 0, /* No default value */
5750                 "RICaction-ToBeSetup-Item"
5751                 },
5752 };
5753 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_4[] = {
5754     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-ToBeSetup-Item */
5755 };
5756 static asn_CHOICE_specifics_t asn_SPC_value_specs_4 = {
5757         sizeof(struct RICaction_ToBeSetup_ItemIEs__value),
5758         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, _asn_ctx),
5759         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, present),
5760         sizeof(((struct RICaction_ToBeSetup_ItemIEs__value *)0)->present),
5761         asn_MAP_value_tag2el_4,
5762         1,      /* Count of tags in the map */
5763         0, 0,
5764         -1      /* Extensions start */
5765 };
5766 static /* Use -fall-defs-global to expose */
5767 asn_TYPE_descriptor_t asn_DEF_value_4 = {
5768         "value",
5769         "value",
5770         &asn_OP_OPEN_TYPE,
5771         0,      /* No effective tags (pointer) */
5772         0,      /* No effective tags (count) */
5773         0,      /* No tags (pointer) */
5774         0,      /* No tags (count) */
5775         { 0, 0, OPEN_TYPE_constraint },
5776         asn_MBR_value_4,
5777         1,      /* Elements count */
5778         &asn_SPC_value_specs_4  /* Additional specs */
5779 };
5780
5781 asn_TYPE_member_t asn_MBR_RICaction_ToBeSetup_ItemIEs_1[] = {
5782         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, id),
5783                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5784                 0,
5785                 &asn_DEF_ProtocolIE_ID,
5786                 0,
5787                 { 0, &asn_PER_memb_id_constr_2,  memb_id_constraint_1 },
5788                 0, 0, /* No default value */
5789                 "id"
5790                 },
5791         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, criticality),
5792                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5793                 0,
5794                 &asn_DEF_Criticality,
5795                 select_RICaction_ToBeSetup_ItemIEs_criticality_type,
5796                 { 0, &asn_PER_memb_criticality_constr_3,  memb_criticality_constraint_1 },
5797                 0, 0, /* No default value */
5798                 "criticality"
5799                 },
5800         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, value),
5801                 -1 /* Ambiguous tag (ANY?) */,
5802                 0,
5803                 &asn_DEF_value_4,
5804                 select_RICaction_ToBeSetup_ItemIEs_value_type,
5805                 { 0, &asn_PER_memb_value_constr_4,  memb_value_constraint_1 },
5806                 0, 0, /* No default value */
5807                 "value"
5808                 },
5809 };
5810 static const ber_tlv_tag_t asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[] = {
5811         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5812 };
5813 static const asn_TYPE_tag2member_t asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1[] = {
5814     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5815     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5816 };
5817 asn_SEQUENCE_specifics_t asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1 = {
5818         sizeof(struct RICaction_ToBeSetup_ItemIEs),
5819         offsetof(struct RICaction_ToBeSetup_ItemIEs, _asn_ctx),
5820         asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1,
5821         2,      /* Count of tags in the map */
5822         0, 0, 0,        /* Optional elements (not needed) */
5823         -1,     /* First extension addition */
5824 };
5825 asn_TYPE_descriptor_t asn_DEF_RICaction_ToBeSetup_ItemIEs = {
5826         "RICaction-ToBeSetup-ItemIEs",
5827         "RICaction-ToBeSetup-ItemIEs",
5828         &asn_OP_SEQUENCE,
5829         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,
5830         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
5831                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
5832         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,     /* Same as above */
5833         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
5834                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
5835         { 0, 0, SEQUENCE_constraint },
5836         asn_MBR_RICaction_ToBeSetup_ItemIEs_1,
5837         3,      /* Elements count */
5838         &asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1    /* Additional specs */
5839 };
5840
5841 static asn_TYPE_member_t asn_MBR_value_8[] = {
5842         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs__value, choice.RICaction_Admitted_Item),
5843                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5844                 0,
5845                 &asn_DEF_RICaction_Admitted_Item,
5846                 0,
5847                 { 0, 0, 0 },
5848                 0, 0, /* No default value */
5849                 "RICaction-Admitted-Item"
5850                 },
5851 };
5852 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_8[] = {
5853     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-Admitted-Item */
5854 };
5855 static asn_CHOICE_specifics_t asn_SPC_value_specs_8 = {
5856         sizeof(struct RICaction_Admitted_ItemIEs__value),
5857         offsetof(struct RICaction_Admitted_ItemIEs__value, _asn_ctx),
5858         offsetof(struct RICaction_Admitted_ItemIEs__value, present),
5859         sizeof(((struct RICaction_Admitted_ItemIEs__value *)0)->present),
5860         asn_MAP_value_tag2el_8,
5861         1,      /* Count of tags in the map */
5862         0, 0,
5863         -1      /* Extensions start */
5864 };
5865 static /* Use -fall-defs-global to expose */
5866 asn_TYPE_descriptor_t asn_DEF_value_8 = {
5867         "value",
5868         "value",
5869         &asn_OP_OPEN_TYPE,
5870         0,      /* No effective tags (pointer) */
5871         0,      /* No effective tags (count) */
5872         0,      /* No tags (pointer) */
5873         0,      /* No tags (count) */
5874         { 0, 0, OPEN_TYPE_constraint },
5875         asn_MBR_value_8,
5876         1,      /* Elements count */
5877         &asn_SPC_value_specs_8  /* Additional specs */
5878 };
5879
5880 asn_TYPE_member_t asn_MBR_RICaction_Admitted_ItemIEs_5[] = {
5881         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, id),
5882                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5883                 0,
5884                 &asn_DEF_ProtocolIE_ID,
5885                 0,
5886                 { 0, &asn_PER_memb_id_constr_6,  memb_id_constraint_5 },
5887                 0, 0, /* No default value */
5888                 "id"
5889                 },
5890         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, criticality),
5891                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5892                 0,
5893                 &asn_DEF_Criticality,
5894                 select_RICaction_Admitted_ItemIEs_criticality_type,
5895                 { 0, &asn_PER_memb_criticality_constr_7,  memb_criticality_constraint_5 },
5896                 0, 0, /* No default value */
5897                 "criticality"
5898                 },
5899         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, value),
5900                 -1 /* Ambiguous tag (ANY?) */,
5901                 0,
5902                 &asn_DEF_value_8,
5903                 select_RICaction_Admitted_ItemIEs_value_type,
5904                 { 0, &asn_PER_memb_value_constr_8,  memb_value_constraint_5 },
5905                 0, 0, /* No default value */
5906                 "value"
5907                 },
5908 };
5909 static const ber_tlv_tag_t asn_DEF_RICaction_Admitted_ItemIEs_tags_5[] = {
5910         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5911 };
5912 static const asn_TYPE_tag2member_t asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5[] = {
5913     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5914     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5915 };
5916 asn_SEQUENCE_specifics_t asn_SPC_RICaction_Admitted_ItemIEs_specs_5 = {
5917         sizeof(struct RICaction_Admitted_ItemIEs),
5918         offsetof(struct RICaction_Admitted_ItemIEs, _asn_ctx),
5919         asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5,
5920         2,      /* Count of tags in the map */
5921         0, 0, 0,        /* Optional elements (not needed) */
5922         -1,     /* First extension addition */
5923 };
5924 asn_TYPE_descriptor_t asn_DEF_RICaction_Admitted_ItemIEs = {
5925         "RICaction-Admitted-ItemIEs",
5926         "RICaction-Admitted-ItemIEs",
5927         &asn_OP_SEQUENCE,
5928         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,
5929         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
5930                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
5931         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,      /* Same as above */
5932         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
5933                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
5934         { 0, 0, SEQUENCE_constraint },
5935         asn_MBR_RICaction_Admitted_ItemIEs_5,
5936         3,      /* Elements count */
5937         &asn_SPC_RICaction_Admitted_ItemIEs_specs_5     /* Additional specs */
5938 };
5939
5940 static asn_TYPE_member_t asn_MBR_value_12[] = {
5941         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs__value, choice.RICaction_NotAdmitted_Item),
5942                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5943                 0,
5944                 &asn_DEF_RICaction_NotAdmitted_Item,
5945                 0,
5946                 { 0, 0, 0 },
5947                 0, 0, /* No default value */
5948                 "RICaction-NotAdmitted-Item"
5949                 },
5950 };
5951 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_12[] = {
5952     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-NotAdmitted-Item */
5953 };
5954 static asn_CHOICE_specifics_t asn_SPC_value_specs_12 = {
5955         sizeof(struct RICaction_NotAdmitted_ItemIEs__value),
5956         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, _asn_ctx),
5957         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, present),
5958         sizeof(((struct RICaction_NotAdmitted_ItemIEs__value *)0)->present),
5959         asn_MAP_value_tag2el_12,
5960         1,      /* Count of tags in the map */
5961         0, 0,
5962         -1      /* Extensions start */
5963 };
5964 static /* Use -fall-defs-global to expose */
5965 asn_TYPE_descriptor_t asn_DEF_value_12 = {
5966         "value",
5967         "value",
5968         &asn_OP_OPEN_TYPE,
5969         0,      /* No effective tags (pointer) */
5970         0,      /* No effective tags (count) */
5971         0,      /* No tags (pointer) */
5972         0,      /* No tags (count) */
5973         { 0, 0, OPEN_TYPE_constraint },
5974         asn_MBR_value_12,
5975         1,      /* Elements count */
5976         &asn_SPC_value_specs_12 /* Additional specs */
5977 };
5978
5979 asn_TYPE_member_t asn_MBR_RICaction_NotAdmitted_ItemIEs_9[] = {
5980         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, id),
5981                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5982                 0,
5983                 &asn_DEF_ProtocolIE_ID,
5984                 0,
5985                 { 0, &asn_PER_memb_id_constr_10,  memb_id_constraint_9 },
5986                 0, 0, /* No default value */
5987                 "id"
5988                 },
5989         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, criticality),
5990                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5991                 0,
5992                 &asn_DEF_Criticality,
5993                 select_RICaction_NotAdmitted_ItemIEs_criticality_type,
5994                 { 0, &asn_PER_memb_criticality_constr_11,  memb_criticality_constraint_9 },
5995                 0, 0, /* No default value */
5996                 "criticality"
5997                 },
5998         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, value),
5999                 -1 /* Ambiguous tag (ANY?) */,
6000                 0,
6001                 &asn_DEF_value_12,
6002                 select_RICaction_NotAdmitted_ItemIEs_value_type,
6003                 { 0, &asn_PER_memb_value_constr_12,  memb_value_constraint_9 },
6004                 0, 0, /* No default value */
6005                 "value"
6006                 },
6007 };
6008 static const ber_tlv_tag_t asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[] = {
6009         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6010 };
6011 static const asn_TYPE_tag2member_t asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9[] = {
6012     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6013     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6014 };
6015 asn_SEQUENCE_specifics_t asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9 = {
6016         sizeof(struct RICaction_NotAdmitted_ItemIEs),
6017         offsetof(struct RICaction_NotAdmitted_ItemIEs, _asn_ctx),
6018         asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9,
6019         2,      /* Count of tags in the map */
6020         0, 0, 0,        /* Optional elements (not needed) */
6021         -1,     /* First extension addition */
6022 };
6023 asn_TYPE_descriptor_t asn_DEF_RICaction_NotAdmitted_ItemIEs = {
6024         "RICaction-NotAdmitted-ItemIEs",
6025         "RICaction-NotAdmitted-ItemIEs",
6026         &asn_OP_SEQUENCE,
6027         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,
6028         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
6029                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
6030         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,   /* Same as above */
6031         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
6032                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
6033         { 0, 0, SEQUENCE_constraint },
6034         asn_MBR_RICaction_NotAdmitted_ItemIEs_9,
6035         3,      /* Elements count */
6036         &asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9  /* Additional specs */
6037 };
6038
6039 static asn_TYPE_member_t asn_MBR_value_16[] = {
6040         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_ItemIEs__value, choice.E2connectionUpdate_Item),
6041                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6042                 0,
6043                 &asn_DEF_E2connectionUpdate_Item,
6044                 0,
6045                 { 0, 0, 0 },
6046                 0, 0, /* No default value */
6047                 "E2connectionUpdate-Item"
6048                 },
6049 };
6050 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_16[] = {
6051     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2connectionUpdate-Item */
6052 };
6053 static asn_CHOICE_specifics_t asn_SPC_value_specs_16 = {
6054         sizeof(struct E2connectionUpdate_ItemIEs__value),
6055         offsetof(struct E2connectionUpdate_ItemIEs__value, _asn_ctx),
6056         offsetof(struct E2connectionUpdate_ItemIEs__value, present),
6057         sizeof(((struct E2connectionUpdate_ItemIEs__value *)0)->present),
6058         asn_MAP_value_tag2el_16,
6059         1,      /* Count of tags in the map */
6060         0, 0,
6061         -1      /* Extensions start */
6062 };
6063 static /* Use -fall-defs-global to expose */
6064 asn_TYPE_descriptor_t asn_DEF_value_16 = {
6065         "value",
6066         "value",
6067         &asn_OP_OPEN_TYPE,
6068         0,      /* No effective tags (pointer) */
6069         0,      /* No effective tags (count) */
6070         0,      /* No tags (pointer) */
6071         0,      /* No tags (count) */
6072         { 0, 0, OPEN_TYPE_constraint },
6073         asn_MBR_value_16,
6074         1,      /* Elements count */
6075         &asn_SPC_value_specs_16 /* Additional specs */
6076 };
6077
6078 asn_TYPE_member_t asn_MBR_E2connectionUpdate_ItemIEs_13[] = {
6079         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_ItemIEs, id),
6080                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6081                 0,
6082                 &asn_DEF_ProtocolIE_ID,
6083                 0,
6084                 { 0, &asn_PER_memb_id_constr_14,  memb_id_constraint_13 },
6085                 0, 0, /* No default value */
6086                 "id"
6087                 },
6088         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_ItemIEs, criticality),
6089                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6090                 0,
6091                 &asn_DEF_Criticality,
6092                 select_E2connectionUpdate_ItemIEs_criticality_type,
6093                 { 0, &asn_PER_memb_criticality_constr_15,  memb_criticality_constraint_13 },
6094                 0, 0, /* No default value */
6095                 "criticality"
6096                 },
6097         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_ItemIEs, value),
6098                 -1 /* Ambiguous tag (ANY?) */,
6099                 0,
6100                 &asn_DEF_value_16,
6101                 select_E2connectionUpdate_ItemIEs_value_type,
6102                 { 0, &asn_PER_memb_value_constr_16,  memb_value_constraint_13 },
6103                 0, 0, /* No default value */
6104                 "value"
6105                 },
6106 };
6107 static const ber_tlv_tag_t asn_DEF_E2connectionUpdate_ItemIEs_tags_13[] = {
6108         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6109 };
6110 static const asn_TYPE_tag2member_t asn_MAP_E2connectionUpdate_ItemIEs_tag2el_13[] = {
6111     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6112     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6113 };
6114 asn_SEQUENCE_specifics_t asn_SPC_E2connectionUpdate_ItemIEs_specs_13 = {
6115         sizeof(struct E2connectionUpdate_ItemIEs),
6116         offsetof(struct E2connectionUpdate_ItemIEs, _asn_ctx),
6117         asn_MAP_E2connectionUpdate_ItemIEs_tag2el_13,
6118         2,      /* Count of tags in the map */
6119         0, 0, 0,        /* Optional elements (not needed) */
6120         -1,     /* First extension addition */
6121 };
6122 asn_TYPE_descriptor_t asn_DEF_E2connectionUpdate_ItemIEs = {
6123         "E2connectionUpdate-ItemIEs",
6124         "E2connectionUpdate-ItemIEs",
6125         &asn_OP_SEQUENCE,
6126         asn_DEF_E2connectionUpdate_ItemIEs_tags_13,
6127         sizeof(asn_DEF_E2connectionUpdate_ItemIEs_tags_13)
6128                 /sizeof(asn_DEF_E2connectionUpdate_ItemIEs_tags_13[0]), /* 1 */
6129         asn_DEF_E2connectionUpdate_ItemIEs_tags_13,     /* Same as above */
6130         sizeof(asn_DEF_E2connectionUpdate_ItemIEs_tags_13)
6131                 /sizeof(asn_DEF_E2connectionUpdate_ItemIEs_tags_13[0]), /* 1 */
6132         { 0, 0, SEQUENCE_constraint },
6133         asn_MBR_E2connectionUpdate_ItemIEs_13,
6134         3,      /* Elements count */
6135         &asn_SPC_E2connectionUpdate_ItemIEs_specs_13    /* Additional specs */
6136 };
6137
6138 static asn_TYPE_member_t asn_MBR_value_20[] = {
6139         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateRemove_ItemIEs__value, choice.E2connectionUpdateRemove_Item),
6140                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6141                 0,
6142                 &asn_DEF_E2connectionUpdateRemove_Item,
6143                 0,
6144                 { 0, 0, 0 },
6145                 0, 0, /* No default value */
6146                 "E2connectionUpdateRemove-Item"
6147                 },
6148 };
6149 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_20[] = {
6150     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2connectionUpdateRemove-Item */
6151 };
6152 static asn_CHOICE_specifics_t asn_SPC_value_specs_20 = {
6153         sizeof(struct E2connectionUpdateRemove_ItemIEs__value),
6154         offsetof(struct E2connectionUpdateRemove_ItemIEs__value, _asn_ctx),
6155         offsetof(struct E2connectionUpdateRemove_ItemIEs__value, present),
6156         sizeof(((struct E2connectionUpdateRemove_ItemIEs__value *)0)->present),
6157         asn_MAP_value_tag2el_20,
6158         1,      /* Count of tags in the map */
6159         0, 0,
6160         -1      /* Extensions start */
6161 };
6162 static /* Use -fall-defs-global to expose */
6163 asn_TYPE_descriptor_t asn_DEF_value_20 = {
6164         "value",
6165         "value",
6166         &asn_OP_OPEN_TYPE,
6167         0,      /* No effective tags (pointer) */
6168         0,      /* No effective tags (count) */
6169         0,      /* No tags (pointer) */
6170         0,      /* No tags (count) */
6171         { 0, 0, OPEN_TYPE_constraint },
6172         asn_MBR_value_20,
6173         1,      /* Elements count */
6174         &asn_SPC_value_specs_20 /* Additional specs */
6175 };
6176
6177 asn_TYPE_member_t asn_MBR_E2connectionUpdateRemove_ItemIEs_17[] = {
6178         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateRemove_ItemIEs, id),
6179                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6180                 0,
6181                 &asn_DEF_ProtocolIE_ID,
6182                 0,
6183                 { 0, &asn_PER_memb_id_constr_18,  memb_id_constraint_17 },
6184                 0, 0, /* No default value */
6185                 "id"
6186                 },
6187         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateRemove_ItemIEs, criticality),
6188                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6189                 0,
6190                 &asn_DEF_Criticality,
6191                 select_E2connectionUpdateRemove_ItemIEs_criticality_type,
6192                 { 0, &asn_PER_memb_criticality_constr_19,  memb_criticality_constraint_17 },
6193                 0, 0, /* No default value */
6194                 "criticality"
6195                 },
6196         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateRemove_ItemIEs, value),
6197                 -1 /* Ambiguous tag (ANY?) */,
6198                 0,
6199                 &asn_DEF_value_20,
6200                 select_E2connectionUpdateRemove_ItemIEs_value_type,
6201                 { 0, &asn_PER_memb_value_constr_20,  memb_value_constraint_17 },
6202                 0, 0, /* No default value */
6203                 "value"
6204                 },
6205 };
6206 static const ber_tlv_tag_t asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17[] = {
6207         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6208 };
6209 static const asn_TYPE_tag2member_t asn_MAP_E2connectionUpdateRemove_ItemIEs_tag2el_17[] = {
6210     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6211     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6212 };
6213 asn_SEQUENCE_specifics_t asn_SPC_E2connectionUpdateRemove_ItemIEs_specs_17 = {
6214         sizeof(struct E2connectionUpdateRemove_ItemIEs),
6215         offsetof(struct E2connectionUpdateRemove_ItemIEs, _asn_ctx),
6216         asn_MAP_E2connectionUpdateRemove_ItemIEs_tag2el_17,
6217         2,      /* Count of tags in the map */
6218         0, 0, 0,        /* Optional elements (not needed) */
6219         -1,     /* First extension addition */
6220 };
6221 asn_TYPE_descriptor_t asn_DEF_E2connectionUpdateRemove_ItemIEs = {
6222         "E2connectionUpdateRemove-ItemIEs",
6223         "E2connectionUpdateRemove-ItemIEs",
6224         &asn_OP_SEQUENCE,
6225         asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17,
6226         sizeof(asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17)
6227                 /sizeof(asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17[0]), /* 1 */
6228         asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17,       /* Same as above */
6229         sizeof(asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17)
6230                 /sizeof(asn_DEF_E2connectionUpdateRemove_ItemIEs_tags_17[0]), /* 1 */
6231         { 0, 0, SEQUENCE_constraint },
6232         asn_MBR_E2connectionUpdateRemove_ItemIEs_17,
6233         3,      /* Elements count */
6234         &asn_SPC_E2connectionUpdateRemove_ItemIEs_specs_17      /* Additional specs */
6235 };
6236
6237 static asn_TYPE_member_t asn_MBR_value_24[] = {
6238         { ATF_NOFLAGS, 0, offsetof(struct E2connectionSetupFailed_ItemIEs__value, choice.E2connectionSetupFailed_Item),
6239                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6240                 0,
6241                 &asn_DEF_E2connectionSetupFailed_Item,
6242                 0,
6243                 { 0, 0, 0 },
6244                 0, 0, /* No default value */
6245                 "E2connectionSetupFailed-Item"
6246                 },
6247 };
6248 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_24[] = {
6249     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2connectionSetupFailed-Item */
6250 };
6251 static asn_CHOICE_specifics_t asn_SPC_value_specs_24 = {
6252         sizeof(struct E2connectionSetupFailed_ItemIEs__value),
6253         offsetof(struct E2connectionSetupFailed_ItemIEs__value, _asn_ctx),
6254         offsetof(struct E2connectionSetupFailed_ItemIEs__value, present),
6255         sizeof(((struct E2connectionSetupFailed_ItemIEs__value *)0)->present),
6256         asn_MAP_value_tag2el_24,
6257         1,      /* Count of tags in the map */
6258         0, 0,
6259         -1      /* Extensions start */
6260 };
6261 static /* Use -fall-defs-global to expose */
6262 asn_TYPE_descriptor_t asn_DEF_value_24 = {
6263         "value",
6264         "value",
6265         &asn_OP_OPEN_TYPE,
6266         0,      /* No effective tags (pointer) */
6267         0,      /* No effective tags (count) */
6268         0,      /* No tags (pointer) */
6269         0,      /* No tags (count) */
6270         { 0, 0, OPEN_TYPE_constraint },
6271         asn_MBR_value_24,
6272         1,      /* Elements count */
6273         &asn_SPC_value_specs_24 /* Additional specs */
6274 };
6275
6276 asn_TYPE_member_t asn_MBR_E2connectionSetupFailed_ItemIEs_21[] = {
6277         { ATF_NOFLAGS, 0, offsetof(struct E2connectionSetupFailed_ItemIEs, id),
6278                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6279                 0,
6280                 &asn_DEF_ProtocolIE_ID,
6281                 0,
6282                 { 0, &asn_PER_memb_id_constr_22,  memb_id_constraint_21 },
6283                 0, 0, /* No default value */
6284                 "id"
6285                 },
6286         { ATF_NOFLAGS, 0, offsetof(struct E2connectionSetupFailed_ItemIEs, criticality),
6287                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6288                 0,
6289                 &asn_DEF_Criticality,
6290                 select_E2connectionSetupFailed_ItemIEs_criticality_type,
6291                 { 0, &asn_PER_memb_criticality_constr_23,  memb_criticality_constraint_21 },
6292                 0, 0, /* No default value */
6293                 "criticality"
6294                 },
6295         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2connectionSetupFailed_ItemIEs, value),
6296                 -1 /* Ambiguous tag (ANY?) */,
6297                 0,
6298                 &asn_DEF_value_24,
6299                 select_E2connectionSetupFailed_ItemIEs_value_type,
6300                 { 0, &asn_PER_memb_value_constr_24,  memb_value_constraint_21 },
6301                 0, 0, /* No default value */
6302                 "value"
6303                 },
6304 };
6305 static const ber_tlv_tag_t asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21[] = {
6306         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6307 };
6308 static const asn_TYPE_tag2member_t asn_MAP_E2connectionSetupFailed_ItemIEs_tag2el_21[] = {
6309     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6310     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6311 };
6312 asn_SEQUENCE_specifics_t asn_SPC_E2connectionSetupFailed_ItemIEs_specs_21 = {
6313         sizeof(struct E2connectionSetupFailed_ItemIEs),
6314         offsetof(struct E2connectionSetupFailed_ItemIEs, _asn_ctx),
6315         asn_MAP_E2connectionSetupFailed_ItemIEs_tag2el_21,
6316         2,      /* Count of tags in the map */
6317         0, 0, 0,        /* Optional elements (not needed) */
6318         -1,     /* First extension addition */
6319 };
6320 asn_TYPE_descriptor_t asn_DEF_E2connectionSetupFailed_ItemIEs = {
6321         "E2connectionSetupFailed-ItemIEs",
6322         "E2connectionSetupFailed-ItemIEs",
6323         &asn_OP_SEQUENCE,
6324         asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21,
6325         sizeof(asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21)
6326                 /sizeof(asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21[0]), /* 1 */
6327         asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21,        /* Same as above */
6328         sizeof(asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21)
6329                 /sizeof(asn_DEF_E2connectionSetupFailed_ItemIEs_tags_21[0]), /* 1 */
6330         { 0, 0, SEQUENCE_constraint },
6331         asn_MBR_E2connectionSetupFailed_ItemIEs_21,
6332         3,      /* Elements count */
6333         &asn_SPC_E2connectionSetupFailed_ItemIEs_specs_21       /* Additional specs */
6334 };
6335
6336 static asn_TYPE_member_t asn_MBR_value_28[] = {
6337         { ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdate_ItemIEs__value, choice.E2nodeComponentConfigUpdate_Item),
6338                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6339                 0,
6340                 &asn_DEF_E2nodeComponentConfigUpdate_Item,
6341                 0,
6342                 { 0, 0, 0 },
6343                 0, 0, /* No default value */
6344                 "E2nodeComponentConfigUpdate-Item"
6345                 },
6346 };
6347 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_28[] = {
6348     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2nodeComponentConfigUpdate-Item */
6349 };
6350 static asn_CHOICE_specifics_t asn_SPC_value_specs_28 = {
6351         sizeof(struct E2nodeComponentConfigUpdate_ItemIEs__value),
6352         offsetof(struct E2nodeComponentConfigUpdate_ItemIEs__value, _asn_ctx),
6353         offsetof(struct E2nodeComponentConfigUpdate_ItemIEs__value, present),
6354         sizeof(((struct E2nodeComponentConfigUpdate_ItemIEs__value *)0)->present),
6355         asn_MAP_value_tag2el_28,
6356         1,      /* Count of tags in the map */
6357         0, 0,
6358         -1      /* Extensions start */
6359 };
6360 static /* Use -fall-defs-global to expose */
6361 asn_TYPE_descriptor_t asn_DEF_value_28 = {
6362         "value",
6363         "value",
6364         &asn_OP_OPEN_TYPE,
6365         0,      /* No effective tags (pointer) */
6366         0,      /* No effective tags (count) */
6367         0,      /* No tags (pointer) */
6368         0,      /* No tags (count) */
6369         { 0, 0, OPEN_TYPE_constraint },
6370         asn_MBR_value_28,
6371         1,      /* Elements count */
6372         &asn_SPC_value_specs_28 /* Additional specs */
6373 };
6374
6375 asn_TYPE_member_t asn_MBR_E2nodeComponentConfigUpdate_ItemIEs_25[] = {
6376         { ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdate_ItemIEs, id),
6377                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6378                 0,
6379                 &asn_DEF_ProtocolIE_ID,
6380                 0,
6381                 { 0, &asn_PER_memb_id_constr_26,  memb_id_constraint_25 },
6382                 0, 0, /* No default value */
6383                 "id"
6384                 },
6385         { ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdate_ItemIEs, criticality),
6386                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6387                 0,
6388                 &asn_DEF_Criticality,
6389                 select_E2nodeComponentConfigUpdate_ItemIEs_criticality_type,
6390                 { 0, &asn_PER_memb_criticality_constr_27,  memb_criticality_constraint_25 },
6391                 0, 0, /* No default value */
6392                 "criticality"
6393                 },
6394         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdate_ItemIEs, value),
6395                 -1 /* Ambiguous tag (ANY?) */,
6396                 0,
6397                 &asn_DEF_value_28,
6398                 select_E2nodeComponentConfigUpdate_ItemIEs_value_type,
6399                 { 0, &asn_PER_memb_value_constr_28,  memb_value_constraint_25 },
6400                 0, 0, /* No default value */
6401                 "value"
6402                 },
6403 };
6404 static const ber_tlv_tag_t asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25[] = {
6405         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6406 };
6407 static const asn_TYPE_tag2member_t asn_MAP_E2nodeComponentConfigUpdate_ItemIEs_tag2el_25[] = {
6408     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6409     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6410 };
6411 asn_SEQUENCE_specifics_t asn_SPC_E2nodeComponentConfigUpdate_ItemIEs_specs_25 = {
6412         sizeof(struct E2nodeComponentConfigUpdate_ItemIEs),
6413         offsetof(struct E2nodeComponentConfigUpdate_ItemIEs, _asn_ctx),
6414         asn_MAP_E2nodeComponentConfigUpdate_ItemIEs_tag2el_25,
6415         2,      /* Count of tags in the map */
6416         0, 0, 0,        /* Optional elements (not needed) */
6417         -1,     /* First extension addition */
6418 };
6419 asn_TYPE_descriptor_t asn_DEF_E2nodeComponentConfigUpdate_ItemIEs = {
6420         "E2nodeComponentConfigUpdate-ItemIEs",
6421         "E2nodeComponentConfigUpdate-ItemIEs",
6422         &asn_OP_SEQUENCE,
6423         asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25,
6424         sizeof(asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25)
6425                 /sizeof(asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25[0]), /* 1 */
6426         asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25,    /* Same as above */
6427         sizeof(asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25)
6428                 /sizeof(asn_DEF_E2nodeComponentConfigUpdate_ItemIEs_tags_25[0]), /* 1 */
6429         { 0, 0, SEQUENCE_constraint },
6430         asn_MBR_E2nodeComponentConfigUpdate_ItemIEs_25,
6431         3,      /* Elements count */
6432         &asn_SPC_E2nodeComponentConfigUpdate_ItemIEs_specs_25   /* Additional specs */
6433 };
6434
6435 static asn_TYPE_member_t asn_MBR_value_32[] = {
6436         { ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs__value, choice.E2nodeComponentConfigUpdateAck_Item),
6437                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6438                 0,
6439                 &asn_DEF_E2nodeComponentConfigUpdateAck_Item,
6440                 0,
6441                 { 0, 0, 0 },
6442                 0, 0, /* No default value */
6443                 "E2nodeComponentConfigUpdateAck-Item"
6444                 },
6445 };
6446 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_32[] = {
6447     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2nodeComponentConfigUpdateAck-Item */
6448 };
6449 static asn_CHOICE_specifics_t asn_SPC_value_specs_32 = {
6450         sizeof(struct E2nodeComponentConfigUpdateAck_ItemIEs__value),
6451         offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs__value, _asn_ctx),
6452         offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs__value, present),
6453         sizeof(((struct E2nodeComponentConfigUpdateAck_ItemIEs__value *)0)->present),
6454         asn_MAP_value_tag2el_32,
6455         1,      /* Count of tags in the map */
6456         0, 0,
6457         -1      /* Extensions start */
6458 };
6459 static /* Use -fall-defs-global to expose */
6460 asn_TYPE_descriptor_t asn_DEF_value_32 = {
6461         "value",
6462         "value",
6463         &asn_OP_OPEN_TYPE,
6464         0,      /* No effective tags (pointer) */
6465         0,      /* No effective tags (count) */
6466         0,      /* No tags (pointer) */
6467         0,      /* No tags (count) */
6468         { 0, 0, OPEN_TYPE_constraint },
6469         asn_MBR_value_32,
6470         1,      /* Elements count */
6471         &asn_SPC_value_specs_32 /* Additional specs */
6472 };
6473
6474 asn_TYPE_member_t asn_MBR_E2nodeComponentConfigUpdateAck_ItemIEs_29[] = {
6475         { ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs, id),
6476                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6477                 0,
6478                 &asn_DEF_ProtocolIE_ID,
6479                 0,
6480                 { 0, &asn_PER_memb_id_constr_30,  memb_id_constraint_29 },
6481                 0, 0, /* No default value */
6482                 "id"
6483                 },
6484         { ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs, criticality),
6485                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6486                 0,
6487                 &asn_DEF_Criticality,
6488                 select_E2nodeComponentConfigUpdateAck_ItemIEs_criticality_type,
6489                 { 0, &asn_PER_memb_criticality_constr_31,  memb_criticality_constraint_29 },
6490                 0, 0, /* No default value */
6491                 "criticality"
6492                 },
6493         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs, value),
6494                 -1 /* Ambiguous tag (ANY?) */,
6495                 0,
6496                 &asn_DEF_value_32,
6497                 select_E2nodeComponentConfigUpdateAck_ItemIEs_value_type,
6498                 { 0, &asn_PER_memb_value_constr_32,  memb_value_constraint_29 },
6499                 0, 0, /* No default value */
6500                 "value"
6501                 },
6502 };
6503 static const ber_tlv_tag_t asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29[] = {
6504         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6505 };
6506 static const asn_TYPE_tag2member_t asn_MAP_E2nodeComponentConfigUpdateAck_ItemIEs_tag2el_29[] = {
6507     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6508     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6509 };
6510 asn_SEQUENCE_specifics_t asn_SPC_E2nodeComponentConfigUpdateAck_ItemIEs_specs_29 = {
6511         sizeof(struct E2nodeComponentConfigUpdateAck_ItemIEs),
6512         offsetof(struct E2nodeComponentConfigUpdateAck_ItemIEs, _asn_ctx),
6513         asn_MAP_E2nodeComponentConfigUpdateAck_ItemIEs_tag2el_29,
6514         2,      /* Count of tags in the map */
6515         0, 0, 0,        /* Optional elements (not needed) */
6516         -1,     /* First extension addition */
6517 };
6518 asn_TYPE_descriptor_t asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs = {
6519         "E2nodeComponentConfigUpdateAck-ItemIEs",
6520         "E2nodeComponentConfigUpdateAck-ItemIEs",
6521         &asn_OP_SEQUENCE,
6522         asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29,
6523         sizeof(asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29)
6524                 /sizeof(asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29[0]), /* 1 */
6525         asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29, /* Same as above */
6526         sizeof(asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29)
6527                 /sizeof(asn_DEF_E2nodeComponentConfigUpdateAck_ItemIEs_tags_29[0]), /* 1 */
6528         { 0, 0, SEQUENCE_constraint },
6529         asn_MBR_E2nodeComponentConfigUpdateAck_ItemIEs_29,
6530         3,      /* Elements count */
6531         &asn_SPC_E2nodeComponentConfigUpdateAck_ItemIEs_specs_29        /* Additional specs */
6532 };
6533
6534 static asn_TYPE_member_t asn_MBR_value_36[] = {
6535         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs__value, choice.RANfunction_Item),
6536                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6537                 0,
6538                 &asn_DEF_RANfunction_Item,
6539                 0,
6540                 { 0, 0, 0 },
6541                 0, 0, /* No default value */
6542                 "RANfunction-Item"
6543                 },
6544 };
6545 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_36[] = {
6546     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunction-Item */
6547 };
6548 static asn_CHOICE_specifics_t asn_SPC_value_specs_36 = {
6549         sizeof(struct RANfunction_ItemIEs__value),
6550         offsetof(struct RANfunction_ItemIEs__value, _asn_ctx),
6551         offsetof(struct RANfunction_ItemIEs__value, present),
6552         sizeof(((struct RANfunction_ItemIEs__value *)0)->present),
6553         asn_MAP_value_tag2el_36,
6554         1,      /* Count of tags in the map */
6555         0, 0,
6556         -1      /* Extensions start */
6557 };
6558 static /* Use -fall-defs-global to expose */
6559 asn_TYPE_descriptor_t asn_DEF_value_36 = {
6560         "value",
6561         "value",
6562         &asn_OP_OPEN_TYPE,
6563         0,      /* No effective tags (pointer) */
6564         0,      /* No effective tags (count) */
6565         0,      /* No tags (pointer) */
6566         0,      /* No tags (count) */
6567         { 0, 0, OPEN_TYPE_constraint },
6568         asn_MBR_value_36,
6569         1,      /* Elements count */
6570         &asn_SPC_value_specs_36 /* Additional specs */
6571 };
6572
6573 asn_TYPE_member_t asn_MBR_RANfunction_ItemIEs_33[] = {
6574         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, id),
6575                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6576                 0,
6577                 &asn_DEF_ProtocolIE_ID,
6578                 0,
6579                 { 0, &asn_PER_memb_id_constr_34,  memb_id_constraint_33 },
6580                 0, 0, /* No default value */
6581                 "id"
6582                 },
6583         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, criticality),
6584                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6585                 0,
6586                 &asn_DEF_Criticality,
6587                 select_RANfunction_ItemIEs_criticality_type,
6588                 { 0, &asn_PER_memb_criticality_constr_35,  memb_criticality_constraint_33 },
6589                 0, 0, /* No default value */
6590                 "criticality"
6591                 },
6592         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, value),
6593                 -1 /* Ambiguous tag (ANY?) */,
6594                 0,
6595                 &asn_DEF_value_36,
6596                 select_RANfunction_ItemIEs_value_type,
6597                 { 0, &asn_PER_memb_value_constr_36,  memb_value_constraint_33 },
6598                 0, 0, /* No default value */
6599                 "value"
6600                 },
6601 };
6602 static const ber_tlv_tag_t asn_DEF_RANfunction_ItemIEs_tags_33[] = {
6603         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6604 };
6605 static const asn_TYPE_tag2member_t asn_MAP_RANfunction_ItemIEs_tag2el_33[] = {
6606     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6607     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6608 };
6609 asn_SEQUENCE_specifics_t asn_SPC_RANfunction_ItemIEs_specs_33 = {
6610         sizeof(struct RANfunction_ItemIEs),
6611         offsetof(struct RANfunction_ItemIEs, _asn_ctx),
6612         asn_MAP_RANfunction_ItemIEs_tag2el_33,
6613         2,      /* Count of tags in the map */
6614         0, 0, 0,        /* Optional elements (not needed) */
6615         -1,     /* First extension addition */
6616 };
6617 asn_TYPE_descriptor_t asn_DEF_RANfunction_ItemIEs = {
6618         "RANfunction-ItemIEs",
6619         "RANfunction-ItemIEs",
6620         &asn_OP_SEQUENCE,
6621         asn_DEF_RANfunction_ItemIEs_tags_33,
6622         sizeof(asn_DEF_RANfunction_ItemIEs_tags_33)
6623                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_33[0]), /* 1 */
6624         asn_DEF_RANfunction_ItemIEs_tags_33,    /* Same as above */
6625         sizeof(asn_DEF_RANfunction_ItemIEs_tags_33)
6626                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_33[0]), /* 1 */
6627         { 0, 0, SEQUENCE_constraint },
6628         asn_MBR_RANfunction_ItemIEs_33,
6629         3,      /* Elements count */
6630         &asn_SPC_RANfunction_ItemIEs_specs_33   /* Additional specs */
6631 };
6632
6633 static asn_TYPE_member_t asn_MBR_value_40[] = {
6634         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs__value, choice.RANfunctionID_Item),
6635                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6636                 0,
6637                 &asn_DEF_RANfunctionID_Item,
6638                 0,
6639                 { 0, 0, 0 },
6640                 0, 0, /* No default value */
6641                 "RANfunctionID-Item"
6642                 },
6643 };
6644 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_40[] = {
6645     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionID-Item */
6646 };
6647 static asn_CHOICE_specifics_t asn_SPC_value_specs_40 = {
6648         sizeof(struct RANfunctionID_ItemIEs__value),
6649         offsetof(struct RANfunctionID_ItemIEs__value, _asn_ctx),
6650         offsetof(struct RANfunctionID_ItemIEs__value, present),
6651         sizeof(((struct RANfunctionID_ItemIEs__value *)0)->present),
6652         asn_MAP_value_tag2el_40,
6653         1,      /* Count of tags in the map */
6654         0, 0,
6655         -1      /* Extensions start */
6656 };
6657 static /* Use -fall-defs-global to expose */
6658 asn_TYPE_descriptor_t asn_DEF_value_40 = {
6659         "value",
6660         "value",
6661         &asn_OP_OPEN_TYPE,
6662         0,      /* No effective tags (pointer) */
6663         0,      /* No effective tags (count) */
6664         0,      /* No tags (pointer) */
6665         0,      /* No tags (count) */
6666         { 0, 0, OPEN_TYPE_constraint },
6667         asn_MBR_value_40,
6668         1,      /* Elements count */
6669         &asn_SPC_value_specs_40 /* Additional specs */
6670 };
6671
6672 asn_TYPE_member_t asn_MBR_RANfunctionID_ItemIEs_37[] = {
6673         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, id),
6674                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6675                 0,
6676                 &asn_DEF_ProtocolIE_ID,
6677                 0,
6678                 { 0, &asn_PER_memb_id_constr_38,  memb_id_constraint_37 },
6679                 0, 0, /* No default value */
6680                 "id"
6681                 },
6682         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, criticality),
6683                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6684                 0,
6685                 &asn_DEF_Criticality,
6686                 select_RANfunctionID_ItemIEs_criticality_type,
6687                 { 0, &asn_PER_memb_criticality_constr_39,  memb_criticality_constraint_37 },
6688                 0, 0, /* No default value */
6689                 "criticality"
6690                 },
6691         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, value),
6692                 -1 /* Ambiguous tag (ANY?) */,
6693                 0,
6694                 &asn_DEF_value_40,
6695                 select_RANfunctionID_ItemIEs_value_type,
6696                 { 0, &asn_PER_memb_value_constr_40,  memb_value_constraint_37 },
6697                 0, 0, /* No default value */
6698                 "value"
6699                 },
6700 };
6701 static const ber_tlv_tag_t asn_DEF_RANfunctionID_ItemIEs_tags_37[] = {
6702         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6703 };
6704 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionID_ItemIEs_tag2el_37[] = {
6705     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6706     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6707 };
6708 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionID_ItemIEs_specs_37 = {
6709         sizeof(struct RANfunctionID_ItemIEs),
6710         offsetof(struct RANfunctionID_ItemIEs, _asn_ctx),
6711         asn_MAP_RANfunctionID_ItemIEs_tag2el_37,
6712         2,      /* Count of tags in the map */
6713         0, 0, 0,        /* Optional elements (not needed) */
6714         -1,     /* First extension addition */
6715 };
6716 asn_TYPE_descriptor_t asn_DEF_RANfunctionID_ItemIEs = {
6717         "RANfunctionID-ItemIEs",
6718         "RANfunctionID-ItemIEs",
6719         &asn_OP_SEQUENCE,
6720         asn_DEF_RANfunctionID_ItemIEs_tags_37,
6721         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_37)
6722                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_37[0]), /* 1 */
6723         asn_DEF_RANfunctionID_ItemIEs_tags_37,  /* Same as above */
6724         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_37)
6725                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_37[0]), /* 1 */
6726         { 0, 0, SEQUENCE_constraint },
6727         asn_MBR_RANfunctionID_ItemIEs_37,
6728         3,      /* Elements count */
6729         &asn_SPC_RANfunctionID_ItemIEs_specs_37 /* Additional specs */
6730 };
6731
6732 static asn_TYPE_member_t asn_MBR_value_44[] = {
6733         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs__value, choice.RANfunctionIDcause_Item),
6734                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6735                 0,
6736                 &asn_DEF_RANfunctionIDcause_Item,
6737                 0,
6738                 { 0, 0, 0 },
6739                 0, 0, /* No default value */
6740                 "RANfunctionIDcause-Item"
6741                 },
6742 };
6743 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_44[] = {
6744     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionIDcause-Item */
6745 };
6746 static asn_CHOICE_specifics_t asn_SPC_value_specs_44 = {
6747         sizeof(struct RANfunctionIDcause_ItemIEs__value),
6748         offsetof(struct RANfunctionIDcause_ItemIEs__value, _asn_ctx),
6749         offsetof(struct RANfunctionIDcause_ItemIEs__value, present),
6750         sizeof(((struct RANfunctionIDcause_ItemIEs__value *)0)->present),
6751         asn_MAP_value_tag2el_44,
6752         1,      /* Count of tags in the map */
6753         0, 0,
6754         -1      /* Extensions start */
6755 };
6756 static /* Use -fall-defs-global to expose */
6757 asn_TYPE_descriptor_t asn_DEF_value_44 = {
6758         "value",
6759         "value",
6760         &asn_OP_OPEN_TYPE,
6761         0,      /* No effective tags (pointer) */
6762         0,      /* No effective tags (count) */
6763         0,      /* No tags (pointer) */
6764         0,      /* No tags (count) */
6765         { 0, 0, OPEN_TYPE_constraint },
6766         asn_MBR_value_44,
6767         1,      /* Elements count */
6768         &asn_SPC_value_specs_44 /* Additional specs */
6769 };
6770
6771 asn_TYPE_member_t asn_MBR_RANfunctionIDcause_ItemIEs_41[] = {
6772         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, id),
6773                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6774                 0,
6775                 &asn_DEF_ProtocolIE_ID,
6776                 0,
6777                 { 0, &asn_PER_memb_id_constr_42,  memb_id_constraint_41 },
6778                 0, 0, /* No default value */
6779                 "id"
6780                 },
6781         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, criticality),
6782                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6783                 0,
6784                 &asn_DEF_Criticality,
6785                 select_RANfunctionIDcause_ItemIEs_criticality_type,
6786                 { 0, &asn_PER_memb_criticality_constr_43,  memb_criticality_constraint_41 },
6787                 0, 0, /* No default value */
6788                 "criticality"
6789                 },
6790         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, value),
6791                 -1 /* Ambiguous tag (ANY?) */,
6792                 0,
6793                 &asn_DEF_value_44,
6794                 select_RANfunctionIDcause_ItemIEs_value_type,
6795                 { 0, &asn_PER_memb_value_constr_44,  memb_value_constraint_41 },
6796                 0, 0, /* No default value */
6797                 "value"
6798                 },
6799 };
6800 static const ber_tlv_tag_t asn_DEF_RANfunctionIDcause_ItemIEs_tags_41[] = {
6801         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6802 };
6803 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_41[] = {
6804     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6805     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6806 };
6807 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionIDcause_ItemIEs_specs_41 = {
6808         sizeof(struct RANfunctionIDcause_ItemIEs),
6809         offsetof(struct RANfunctionIDcause_ItemIEs, _asn_ctx),
6810         asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_41,
6811         2,      /* Count of tags in the map */
6812         0, 0, 0,        /* Optional elements (not needed) */
6813         -1,     /* First extension addition */
6814 };
6815 asn_TYPE_descriptor_t asn_DEF_RANfunctionIDcause_ItemIEs = {
6816         "RANfunctionIDcause-ItemIEs",
6817         "RANfunctionIDcause-ItemIEs",
6818         &asn_OP_SEQUENCE,
6819         asn_DEF_RANfunctionIDcause_ItemIEs_tags_41,
6820         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_41)
6821                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_41[0]), /* 1 */
6822         asn_DEF_RANfunctionIDcause_ItemIEs_tags_41,     /* Same as above */
6823         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_41)
6824                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_41[0]), /* 1 */
6825         { 0, 0, SEQUENCE_constraint },
6826         asn_MBR_RANfunctionIDcause_ItemIEs_41,
6827         3,      /* Elements count */
6828         &asn_SPC_RANfunctionIDcause_ItemIEs_specs_41    /* Additional specs */
6829 };
6830
6831 static asn_TYPE_member_t asn_MBR_value_48[] = {
6832         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICrequestID),
6833                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6834                 0,
6835                 &asn_DEF_RICrequestID,
6836                 0,
6837                 { 0, 0, 0 },
6838                 0, 0, /* No default value */
6839                 "RICrequestID"
6840                 },
6841         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RANfunctionID),
6842                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6843                 0,
6844                 &asn_DEF_RANfunctionID,
6845                 0,
6846                 { 0, 0, 0 },
6847                 0, 0, /* No default value */
6848                 "RANfunctionID"
6849                 },
6850         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICsubscriptionDetails),
6851                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6852                 0,
6853                 &asn_DEF_RICsubscriptionDetails,
6854                 0,
6855                 { 0, 0, 0 },
6856                 0, 0, /* No default value */
6857                 "RICsubscriptionDetails"
6858                 },
6859 };
6860 static const unsigned asn_MAP_value_to_canonical_48[] = { 1, 0, 2 };
6861 static const unsigned asn_MAP_value_from_canonical_48[] = { 1, 0, 2 };
6862 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_48[] = {
6863     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6864     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
6865     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* RICsubscriptionDetails */
6866 };
6867 static asn_CHOICE_specifics_t asn_SPC_value_specs_48 = {
6868         sizeof(struct RICsubscriptionRequest_IEs__value),
6869         offsetof(struct RICsubscriptionRequest_IEs__value, _asn_ctx),
6870         offsetof(struct RICsubscriptionRequest_IEs__value, present),
6871         sizeof(((struct RICsubscriptionRequest_IEs__value *)0)->present),
6872         asn_MAP_value_tag2el_48,
6873         3,      /* Count of tags in the map */
6874         asn_MAP_value_to_canonical_48,
6875         asn_MAP_value_from_canonical_48,
6876         -1      /* Extensions start */
6877 };
6878 static /* Use -fall-defs-global to expose */
6879 asn_TYPE_descriptor_t asn_DEF_value_48 = {
6880         "value",
6881         "value",
6882         &asn_OP_OPEN_TYPE,
6883         0,      /* No effective tags (pointer) */
6884         0,      /* No effective tags (count) */
6885         0,      /* No tags (pointer) */
6886         0,      /* No tags (count) */
6887         { 0, 0, OPEN_TYPE_constraint },
6888         asn_MBR_value_48,
6889         3,      /* Elements count */
6890         &asn_SPC_value_specs_48 /* Additional specs */
6891 };
6892
6893 asn_TYPE_member_t asn_MBR_RICsubscriptionRequest_IEs_45[] = {
6894         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, id),
6895                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6896                 0,
6897                 &asn_DEF_ProtocolIE_ID,
6898                 0,
6899                 { 0, &asn_PER_memb_id_constr_46,  memb_id_constraint_45 },
6900                 0, 0, /* No default value */
6901                 "id"
6902                 },
6903         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, criticality),
6904                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6905                 0,
6906                 &asn_DEF_Criticality,
6907                 select_RICsubscriptionRequest_IEs_criticality_type,
6908                 { 0, &asn_PER_memb_criticality_constr_47,  memb_criticality_constraint_45 },
6909                 0, 0, /* No default value */
6910                 "criticality"
6911                 },
6912         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, value),
6913                 -1 /* Ambiguous tag (ANY?) */,
6914                 0,
6915                 &asn_DEF_value_48,
6916                 select_RICsubscriptionRequest_IEs_value_type,
6917                 { 0, &asn_PER_memb_value_constr_48,  memb_value_constraint_45 },
6918                 0, 0, /* No default value */
6919                 "value"
6920                 },
6921 };
6922 static const ber_tlv_tag_t asn_DEF_RICsubscriptionRequest_IEs_tags_45[] = {
6923         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6924 };
6925 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionRequest_IEs_tag2el_45[] = {
6926     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6927     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6928 };
6929 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionRequest_IEs_specs_45 = {
6930         sizeof(struct RICsubscriptionRequest_IEs),
6931         offsetof(struct RICsubscriptionRequest_IEs, _asn_ctx),
6932         asn_MAP_RICsubscriptionRequest_IEs_tag2el_45,
6933         2,      /* Count of tags in the map */
6934         0, 0, 0,        /* Optional elements (not needed) */
6935         -1,     /* First extension addition */
6936 };
6937 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionRequest_IEs = {
6938         "RICsubscriptionRequest-IEs",
6939         "RICsubscriptionRequest-IEs",
6940         &asn_OP_SEQUENCE,
6941         asn_DEF_RICsubscriptionRequest_IEs_tags_45,
6942         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_45)
6943                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_45[0]), /* 1 */
6944         asn_DEF_RICsubscriptionRequest_IEs_tags_45,     /* Same as above */
6945         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_45)
6946                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_45[0]), /* 1 */
6947         { 0, 0, SEQUENCE_constraint },
6948         asn_MBR_RICsubscriptionRequest_IEs_45,
6949         3,      /* Elements count */
6950         &asn_SPC_RICsubscriptionRequest_IEs_specs_45    /* Additional specs */
6951 };
6952
6953 static asn_TYPE_member_t asn_MBR_value_52[] = {
6954         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICrequestID),
6955                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6956                 0,
6957                 &asn_DEF_RICrequestID,
6958                 0,
6959                 { 0, 0, 0 },
6960                 0, 0, /* No default value */
6961                 "RICrequestID"
6962                 },
6963         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RANfunctionID),
6964                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6965                 0,
6966                 &asn_DEF_RANfunctionID,
6967                 0,
6968                 { 0, 0, 0 },
6969                 0, 0, /* No default value */
6970                 "RANfunctionID"
6971                 },
6972         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_Admitted_List),
6973                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6974                 0,
6975                 &asn_DEF_RICaction_Admitted_List,
6976                 0,
6977                 { 0, 0, 0 },
6978                 0, 0, /* No default value */
6979                 "RICaction-Admitted-List"
6980                 },
6981         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_NotAdmitted_List),
6982                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6983                 0,
6984                 &asn_DEF_RICaction_NotAdmitted_List,
6985                 0,
6986                 { 0, 0, 0 },
6987                 0, 0, /* No default value */
6988                 "RICaction-NotAdmitted-List"
6989                 },
6990 };
6991 static const unsigned asn_MAP_value_to_canonical_52[] = { 1, 0, 2, 3 };
6992 static const unsigned asn_MAP_value_from_canonical_52[] = { 1, 0, 2, 3 };
6993 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_52[] = {
6994     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6995     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
6996     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-Admitted-List */
6997     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* RICaction-NotAdmitted-List */
6998 };
6999 static asn_CHOICE_specifics_t asn_SPC_value_specs_52 = {
7000         sizeof(struct RICsubscriptionResponse_IEs__value),
7001         offsetof(struct RICsubscriptionResponse_IEs__value, _asn_ctx),
7002         offsetof(struct RICsubscriptionResponse_IEs__value, present),
7003         sizeof(((struct RICsubscriptionResponse_IEs__value *)0)->present),
7004         asn_MAP_value_tag2el_52,
7005         4,      /* Count of tags in the map */
7006         asn_MAP_value_to_canonical_52,
7007         asn_MAP_value_from_canonical_52,
7008         -1      /* Extensions start */
7009 };
7010 static /* Use -fall-defs-global to expose */
7011 asn_TYPE_descriptor_t asn_DEF_value_52 = {
7012         "value",
7013         "value",
7014         &asn_OP_OPEN_TYPE,
7015         0,      /* No effective tags (pointer) */
7016         0,      /* No effective tags (count) */
7017         0,      /* No tags (pointer) */
7018         0,      /* No tags (count) */
7019         { 0, 0, OPEN_TYPE_constraint },
7020         asn_MBR_value_52,
7021         4,      /* Elements count */
7022         &asn_SPC_value_specs_52 /* Additional specs */
7023 };
7024
7025 asn_TYPE_member_t asn_MBR_RICsubscriptionResponse_IEs_49[] = {
7026         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, id),
7027                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7028                 0,
7029                 &asn_DEF_ProtocolIE_ID,
7030                 0,
7031                 { 0, &asn_PER_memb_id_constr_50,  memb_id_constraint_49 },
7032                 0, 0, /* No default value */
7033                 "id"
7034                 },
7035         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, criticality),
7036                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7037                 0,
7038                 &asn_DEF_Criticality,
7039                 select_RICsubscriptionResponse_IEs_criticality_type,
7040                 { 0, &asn_PER_memb_criticality_constr_51,  memb_criticality_constraint_49 },
7041                 0, 0, /* No default value */
7042                 "criticality"
7043                 },
7044         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, value),
7045                 -1 /* Ambiguous tag (ANY?) */,
7046                 0,
7047                 &asn_DEF_value_52,
7048                 select_RICsubscriptionResponse_IEs_value_type,
7049                 { 0, &asn_PER_memb_value_constr_52,  memb_value_constraint_49 },
7050                 0, 0, /* No default value */
7051                 "value"
7052                 },
7053 };
7054 static const ber_tlv_tag_t asn_DEF_RICsubscriptionResponse_IEs_tags_49[] = {
7055         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7056 };
7057 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionResponse_IEs_tag2el_49[] = {
7058     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7059     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7060 };
7061 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionResponse_IEs_specs_49 = {
7062         sizeof(struct RICsubscriptionResponse_IEs),
7063         offsetof(struct RICsubscriptionResponse_IEs, _asn_ctx),
7064         asn_MAP_RICsubscriptionResponse_IEs_tag2el_49,
7065         2,      /* Count of tags in the map */
7066         0, 0, 0,        /* Optional elements (not needed) */
7067         -1,     /* First extension addition */
7068 };
7069 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionResponse_IEs = {
7070         "RICsubscriptionResponse-IEs",
7071         "RICsubscriptionResponse-IEs",
7072         &asn_OP_SEQUENCE,
7073         asn_DEF_RICsubscriptionResponse_IEs_tags_49,
7074         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_49)
7075                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_49[0]), /* 1 */
7076         asn_DEF_RICsubscriptionResponse_IEs_tags_49,    /* Same as above */
7077         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_49)
7078                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_49[0]), /* 1 */
7079         { 0, 0, SEQUENCE_constraint },
7080         asn_MBR_RICsubscriptionResponse_IEs_49,
7081         3,      /* Elements count */
7082         &asn_SPC_RICsubscriptionResponse_IEs_specs_49   /* Additional specs */
7083 };
7084
7085 static asn_TYPE_member_t asn_MBR_value_56[] = {
7086         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICrequestID),
7087                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7088                 0,
7089                 &asn_DEF_RICrequestID,
7090                 0,
7091                 { 0, 0, 0 },
7092                 0, 0, /* No default value */
7093                 "RICrequestID"
7094                 },
7095         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RANfunctionID),
7096                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7097                 0,
7098                 &asn_DEF_RANfunctionID,
7099                 0,
7100                 { 0, 0, 0 },
7101                 0, 0, /* No default value */
7102                 "RANfunctionID"
7103                 },
7104         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICaction_NotAdmitted_List),
7105                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7106                 0,
7107                 &asn_DEF_RICaction_NotAdmitted_List,
7108                 0,
7109                 { 0, 0, 0 },
7110                 0, 0, /* No default value */
7111                 "RICaction-NotAdmitted-List"
7112                 },
7113         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.CriticalityDiagnostics),
7114                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7115                 0,
7116                 &asn_DEF_CriticalityDiagnostics,
7117                 0,
7118                 { 0, 0, 0 },
7119                 0, 0, /* No default value */
7120                 "CriticalityDiagnostics"
7121                 },
7122 };
7123 static const unsigned asn_MAP_value_to_canonical_56[] = { 1, 0, 2, 3 };
7124 static const unsigned asn_MAP_value_from_canonical_56[] = { 1, 0, 2, 3 };
7125 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_56[] = {
7126     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
7127     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
7128     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-NotAdmitted-List */
7129     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* CriticalityDiagnostics */
7130 };
7131 static asn_CHOICE_specifics_t asn_SPC_value_specs_56 = {
7132         sizeof(struct RICsubscriptionFailure_IEs__value),
7133         offsetof(struct RICsubscriptionFailure_IEs__value, _asn_ctx),
7134         offsetof(struct RICsubscriptionFailure_IEs__value, present),
7135         sizeof(((struct RICsubscriptionFailure_IEs__value *)0)->present),
7136         asn_MAP_value_tag2el_56,
7137         4,      /* Count of tags in the map */
7138         asn_MAP_value_to_canonical_56,
7139         asn_MAP_value_from_canonical_56,
7140         -1      /* Extensions start */
7141 };
7142 static /* Use -fall-defs-global to expose */
7143 asn_TYPE_descriptor_t asn_DEF_value_56 = {
7144         "value",
7145         "value",
7146         &asn_OP_OPEN_TYPE,
7147         0,      /* No effective tags (pointer) */
7148         0,      /* No effective tags (count) */
7149         0,      /* No tags (pointer) */
7150         0,      /* No tags (count) */
7151         { 0, 0, OPEN_TYPE_constraint },
7152         asn_MBR_value_56,
7153         4,      /* Elements count */
7154         &asn_SPC_value_specs_56 /* Additional specs */
7155 };
7156
7157 asn_TYPE_member_t asn_MBR_RICsubscriptionFailure_IEs_53[] = {
7158         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, id),
7159                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7160                 0,
7161                 &asn_DEF_ProtocolIE_ID,
7162                 0,
7163                 { 0, &asn_PER_memb_id_constr_54,  memb_id_constraint_53 },
7164                 0, 0, /* No default value */
7165                 "id"
7166                 },
7167         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, criticality),
7168                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7169                 0,
7170                 &asn_DEF_Criticality,
7171                 select_RICsubscriptionFailure_IEs_criticality_type,
7172                 { 0, &asn_PER_memb_criticality_constr_55,  memb_criticality_constraint_53 },
7173                 0, 0, /* No default value */
7174                 "criticality"
7175                 },
7176         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, value),
7177                 -1 /* Ambiguous tag (ANY?) */,
7178                 0,
7179                 &asn_DEF_value_56,
7180                 select_RICsubscriptionFailure_IEs_value_type,
7181                 { 0, &asn_PER_memb_value_constr_56,  memb_value_constraint_53 },
7182                 0, 0, /* No default value */
7183                 "value"
7184                 },
7185 };
7186 static const ber_tlv_tag_t asn_DEF_RICsubscriptionFailure_IEs_tags_53[] = {
7187         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7188 };
7189 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionFailure_IEs_tag2el_53[] = {
7190     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7191     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7192 };
7193 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionFailure_IEs_specs_53 = {
7194         sizeof(struct RICsubscriptionFailure_IEs),
7195         offsetof(struct RICsubscriptionFailure_IEs, _asn_ctx),
7196         asn_MAP_RICsubscriptionFailure_IEs_tag2el_53,
7197         2,      /* Count of tags in the map */
7198         0, 0, 0,        /* Optional elements (not needed) */
7199         -1,     /* First extension addition */
7200 };
7201 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionFailure_IEs = {
7202         "RICsubscriptionFailure-IEs",
7203         "RICsubscriptionFailure-IEs",
7204         &asn_OP_SEQUENCE,
7205         asn_DEF_RICsubscriptionFailure_IEs_tags_53,
7206         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_53)
7207                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_53[0]), /* 1 */
7208         asn_DEF_RICsubscriptionFailure_IEs_tags_53,     /* Same as above */
7209         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_53)
7210                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_53[0]), /* 1 */
7211         { 0, 0, SEQUENCE_constraint },
7212         asn_MBR_RICsubscriptionFailure_IEs_53,
7213         3,      /* Elements count */
7214         &asn_SPC_RICsubscriptionFailure_IEs_specs_53    /* Additional specs */
7215 };
7216
7217 static asn_TYPE_member_t asn_MBR_value_60[] = {
7218         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RICrequestID),
7219                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7220                 0,
7221                 &asn_DEF_RICrequestID,
7222                 0,
7223                 { 0, 0, 0 },
7224                 0, 0, /* No default value */
7225                 "RICrequestID"
7226                 },
7227         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RANfunctionID),
7228                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7229                 0,
7230                 &asn_DEF_RANfunctionID,
7231                 0,
7232                 { 0, 0, 0 },
7233                 0, 0, /* No default value */
7234                 "RANfunctionID"
7235                 },
7236 };
7237 static const unsigned asn_MAP_value_to_canonical_60[] = { 1, 0 };
7238 static const unsigned asn_MAP_value_from_canonical_60[] = { 1, 0 };
7239 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_60[] = {
7240     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
7241     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
7242 };
7243 static asn_CHOICE_specifics_t asn_SPC_value_specs_60 = {
7244         sizeof(struct RICsubscriptionDeleteRequest_IEs__value),
7245         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, _asn_ctx),
7246         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, present),
7247         sizeof(((struct RICsubscriptionDeleteRequest_IEs__value *)0)->present),
7248         asn_MAP_value_tag2el_60,
7249         2,      /* Count of tags in the map */
7250         asn_MAP_value_to_canonical_60,
7251         asn_MAP_value_from_canonical_60,
7252         -1      /* Extensions start */
7253 };
7254 static /* Use -fall-defs-global to expose */
7255 asn_TYPE_descriptor_t asn_DEF_value_60 = {
7256         "value",
7257         "value",
7258         &asn_OP_OPEN_TYPE,
7259         0,      /* No effective tags (pointer) */
7260         0,      /* No effective tags (count) */
7261         0,      /* No tags (pointer) */
7262         0,      /* No tags (count) */
7263         { 0, 0, OPEN_TYPE_constraint },
7264         asn_MBR_value_60,
7265         2,      /* Elements count */
7266         &asn_SPC_value_specs_60 /* Additional specs */
7267 };
7268
7269 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteRequest_IEs_57[] = {
7270         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, id),
7271                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7272                 0,
7273                 &asn_DEF_ProtocolIE_ID,
7274                 0,
7275                 { 0, &asn_PER_memb_id_constr_58,  memb_id_constraint_57 },
7276                 0, 0, /* No default value */
7277                 "id"
7278                 },
7279         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, criticality),
7280                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7281                 0,
7282                 &asn_DEF_Criticality,
7283                 select_RICsubscriptionDeleteRequest_IEs_criticality_type,
7284                 { 0, &asn_PER_memb_criticality_constr_59,  memb_criticality_constraint_57 },
7285                 0, 0, /* No default value */
7286                 "criticality"
7287                 },
7288         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, value),
7289                 -1 /* Ambiguous tag (ANY?) */,
7290                 0,
7291                 &asn_DEF_value_60,
7292                 select_RICsubscriptionDeleteRequest_IEs_value_type,
7293                 { 0, &asn_PER_memb_value_constr_60,  memb_value_constraint_57 },
7294                 0, 0, /* No default value */
7295                 "value"
7296                 },
7297 };
7298 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57[] = {
7299         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7300 };
7301 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_57[] = {
7302     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7303     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7304 };
7305 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_57 = {
7306         sizeof(struct RICsubscriptionDeleteRequest_IEs),
7307         offsetof(struct RICsubscriptionDeleteRequest_IEs, _asn_ctx),
7308         asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_57,
7309         2,      /* Count of tags in the map */
7310         0, 0, 0,        /* Optional elements (not needed) */
7311         -1,     /* First extension addition */
7312 };
7313 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteRequest_IEs = {
7314         "RICsubscriptionDeleteRequest-IEs",
7315         "RICsubscriptionDeleteRequest-IEs",
7316         &asn_OP_SEQUENCE,
7317         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57,
7318         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57)
7319                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57[0]), /* 1 */
7320         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57,       /* Same as above */
7321         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57)
7322                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_57[0]), /* 1 */
7323         { 0, 0, SEQUENCE_constraint },
7324         asn_MBR_RICsubscriptionDeleteRequest_IEs_57,
7325         3,      /* Elements count */
7326         &asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_57      /* Additional specs */
7327 };
7328
7329 static asn_TYPE_member_t asn_MBR_value_64[] = {
7330         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RICrequestID),
7331                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7332                 0,
7333                 &asn_DEF_RICrequestID,
7334                 0,
7335                 { 0, 0, 0 },
7336                 0, 0, /* No default value */
7337                 "RICrequestID"
7338                 },
7339         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RANfunctionID),
7340                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7341                 0,
7342                 &asn_DEF_RANfunctionID,
7343                 0,
7344                 { 0, 0, 0 },
7345                 0, 0, /* No default value */
7346                 "RANfunctionID"
7347                 },
7348 };
7349 static const unsigned asn_MAP_value_to_canonical_64[] = { 1, 0 };
7350 static const unsigned asn_MAP_value_from_canonical_64[] = { 1, 0 };
7351 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_64[] = {
7352     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
7353     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
7354 };
7355 static asn_CHOICE_specifics_t asn_SPC_value_specs_64 = {
7356         sizeof(struct RICsubscriptionDeleteResponse_IEs__value),
7357         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, _asn_ctx),
7358         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, present),
7359         sizeof(((struct RICsubscriptionDeleteResponse_IEs__value *)0)->present),
7360         asn_MAP_value_tag2el_64,
7361         2,      /* Count of tags in the map */
7362         asn_MAP_value_to_canonical_64,
7363         asn_MAP_value_from_canonical_64,
7364         -1      /* Extensions start */
7365 };
7366 static /* Use -fall-defs-global to expose */
7367 asn_TYPE_descriptor_t asn_DEF_value_64 = {
7368         "value",
7369         "value",
7370         &asn_OP_OPEN_TYPE,
7371         0,      /* No effective tags (pointer) */
7372         0,      /* No effective tags (count) */
7373         0,      /* No tags (pointer) */
7374         0,      /* No tags (count) */
7375         { 0, 0, OPEN_TYPE_constraint },
7376         asn_MBR_value_64,
7377         2,      /* Elements count */
7378         &asn_SPC_value_specs_64 /* Additional specs */
7379 };
7380
7381 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteResponse_IEs_61[] = {
7382         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, id),
7383                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7384                 0,
7385                 &asn_DEF_ProtocolIE_ID,
7386                 0,
7387                 { 0, &asn_PER_memb_id_constr_62,  memb_id_constraint_61 },
7388                 0, 0, /* No default value */
7389                 "id"
7390                 },
7391         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, criticality),
7392                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7393                 0,
7394                 &asn_DEF_Criticality,
7395                 select_RICsubscriptionDeleteResponse_IEs_criticality_type,
7396                 { 0, &asn_PER_memb_criticality_constr_63,  memb_criticality_constraint_61 },
7397                 0, 0, /* No default value */
7398                 "criticality"
7399                 },
7400         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, value),
7401                 -1 /* Ambiguous tag (ANY?) */,
7402                 0,
7403                 &asn_DEF_value_64,
7404                 select_RICsubscriptionDeleteResponse_IEs_value_type,
7405                 { 0, &asn_PER_memb_value_constr_64,  memb_value_constraint_61 },
7406                 0, 0, /* No default value */
7407                 "value"
7408                 },
7409 };
7410 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61[] = {
7411         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7412 };
7413 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_61[] = {
7414     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7415     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7416 };
7417 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_61 = {
7418         sizeof(struct RICsubscriptionDeleteResponse_IEs),
7419         offsetof(struct RICsubscriptionDeleteResponse_IEs, _asn_ctx),
7420         asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_61,
7421         2,      /* Count of tags in the map */
7422         0, 0, 0,        /* Optional elements (not needed) */
7423         -1,     /* First extension addition */
7424 };
7425 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteResponse_IEs = {
7426         "RICsubscriptionDeleteResponse-IEs",
7427         "RICsubscriptionDeleteResponse-IEs",
7428         &asn_OP_SEQUENCE,
7429         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61,
7430         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61)
7431                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61[0]), /* 1 */
7432         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61,      /* Same as above */
7433         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61)
7434                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_61[0]), /* 1 */
7435         { 0, 0, SEQUENCE_constraint },
7436         asn_MBR_RICsubscriptionDeleteResponse_IEs_61,
7437         3,      /* Elements count */
7438         &asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_61     /* Additional specs */
7439 };
7440
7441 static asn_TYPE_member_t asn_MBR_value_68[] = {
7442         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RICrequestID),
7443                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7444                 0,
7445                 &asn_DEF_RICrequestID,
7446                 0,
7447                 { 0, 0, 0 },
7448                 0, 0, /* No default value */
7449                 "RICrequestID"
7450                 },
7451         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RANfunctionID),
7452                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7453                 0,
7454                 &asn_DEF_RANfunctionID,
7455                 0,
7456                 { 0, 0, 0 },
7457                 0, 0, /* No default value */
7458                 "RANfunctionID"
7459                 },
7460         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.Cause),
7461                 -1 /* Ambiguous tag (CHOICE?) */,
7462                 0,
7463                 &asn_DEF_Cause,
7464                 0,
7465                 { 0, 0, 0 },
7466                 0, 0, /* No default value */
7467                 "Cause"
7468                 },
7469         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.CriticalityDiagnostics),
7470                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7471                 0,
7472                 &asn_DEF_CriticalityDiagnostics,
7473                 0,
7474                 { 0, 0, 0 },
7475                 0, 0, /* No default value */
7476                 "CriticalityDiagnostics"
7477                 },
7478 };
7479 static const unsigned asn_MAP_value_to_canonical_68[] = { 1, 0, 3, 2 };
7480 static const unsigned asn_MAP_value_from_canonical_68[] = { 1, 0, 3, 2 };
7481 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_68[] = {
7482     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
7483     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
7484     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
7485     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
7486     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
7487     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
7488     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
7489     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
7490 };
7491 static asn_CHOICE_specifics_t asn_SPC_value_specs_68 = {
7492         sizeof(struct RICsubscriptionDeleteFailure_IEs__value),
7493         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, _asn_ctx),
7494         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, present),
7495         sizeof(((struct RICsubscriptionDeleteFailure_IEs__value *)0)->present),
7496         asn_MAP_value_tag2el_68,
7497         8,      /* Count of tags in the map */
7498         asn_MAP_value_to_canonical_68,
7499         asn_MAP_value_from_canonical_68,
7500         -1      /* Extensions start */
7501 };
7502 static /* Use -fall-defs-global to expose */
7503 asn_TYPE_descriptor_t asn_DEF_value_68 = {
7504         "value",
7505         "value",
7506         &asn_OP_OPEN_TYPE,
7507         0,      /* No effective tags (pointer) */
7508         0,      /* No effective tags (count) */
7509         0,      /* No tags (pointer) */
7510         0,      /* No tags (count) */
7511         { 0, 0, OPEN_TYPE_constraint },
7512         asn_MBR_value_68,
7513         4,      /* Elements count */
7514         &asn_SPC_value_specs_68 /* Additional specs */
7515 };
7516
7517 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteFailure_IEs_65[] = {
7518         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, id),
7519                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7520                 0,
7521                 &asn_DEF_ProtocolIE_ID,
7522                 0,
7523                 { 0, &asn_PER_memb_id_constr_66,  memb_id_constraint_65 },
7524                 0, 0, /* No default value */
7525                 "id"
7526                 },
7527         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, criticality),
7528                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7529                 0,
7530                 &asn_DEF_Criticality,
7531                 select_RICsubscriptionDeleteFailure_IEs_criticality_type,
7532                 { 0, &asn_PER_memb_criticality_constr_67,  memb_criticality_constraint_65 },
7533                 0, 0, /* No default value */
7534                 "criticality"
7535                 },
7536         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, value),
7537                 -1 /* Ambiguous tag (ANY?) */,
7538                 0,
7539                 &asn_DEF_value_68,
7540                 select_RICsubscriptionDeleteFailure_IEs_value_type,
7541                 { 0, &asn_PER_memb_value_constr_68,  memb_value_constraint_65 },
7542                 0, 0, /* No default value */
7543                 "value"
7544                 },
7545 };
7546 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65[] = {
7547         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7548 };
7549 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_65[] = {
7550     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7551     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7552 };
7553 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_65 = {
7554         sizeof(struct RICsubscriptionDeleteFailure_IEs),
7555         offsetof(struct RICsubscriptionDeleteFailure_IEs, _asn_ctx),
7556         asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_65,
7557         2,      /* Count of tags in the map */
7558         0, 0, 0,        /* Optional elements (not needed) */
7559         -1,     /* First extension addition */
7560 };
7561 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteFailure_IEs = {
7562         "RICsubscriptionDeleteFailure-IEs",
7563         "RICsubscriptionDeleteFailure-IEs",
7564         &asn_OP_SEQUENCE,
7565         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65,
7566         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65)
7567                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65[0]), /* 1 */
7568         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65,       /* Same as above */
7569         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65)
7570                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_65[0]), /* 1 */
7571         { 0, 0, SEQUENCE_constraint },
7572         asn_MBR_RICsubscriptionDeleteFailure_IEs_65,
7573         3,      /* Elements count */
7574         &asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_65      /* Additional specs */
7575 };
7576
7577 static asn_TYPE_member_t asn_MBR_value_72[] = {
7578         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICrequestID),
7579                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7580                 0,
7581                 &asn_DEF_RICrequestID,
7582                 0,
7583                 { 0, 0, 0 },
7584                 0, 0, /* No default value */
7585                 "RICrequestID"
7586                 },
7587         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RANfunctionID),
7588                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7589                 0,
7590                 &asn_DEF_RANfunctionID,
7591                 0,
7592                 { 0, 0, 0 },
7593                 0, 0, /* No default value */
7594                 "RANfunctionID"
7595                 },
7596         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICactionID),
7597                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7598                 0,
7599                 &asn_DEF_RICactionID,
7600                 0,
7601                 { 0, 0, 0 },
7602                 0, 0, /* No default value */
7603                 "RICactionID"
7604                 },
7605         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationSN),
7606                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7607                 0,
7608                 &asn_DEF_RICindicationSN,
7609                 0,
7610                 { 0, 0, 0 },
7611                 0, 0, /* No default value */
7612                 "RICindicationSN"
7613                 },
7614         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationType),
7615                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7616                 0,
7617                 &asn_DEF_RICindicationType,
7618                 0,
7619                 { 0, 0, 0 },
7620                 0, 0, /* No default value */
7621                 "RICindicationType"
7622                 },
7623         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationHeader),
7624                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7625                 0,
7626                 &asn_DEF_RICindicationHeader,
7627                 0,
7628                 { 0, 0, 0 },
7629                 0, 0, /* No default value */
7630                 "RICindicationHeader"
7631                 },
7632         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationMessage),
7633                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7634                 0,
7635                 &asn_DEF_RICindicationMessage,
7636                 0,
7637                 { 0, 0, 0 },
7638                 0, 0, /* No default value */
7639                 "RICindicationMessage"
7640                 },
7641         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICcallProcessID),
7642                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7643                 0,
7644                 &asn_DEF_RICcallProcessID,
7645                 0,
7646                 { 0, 0, 0 },
7647                 0, 0, /* No default value */
7648                 "RICcallProcessID"
7649                 },
7650 };
7651 static const unsigned asn_MAP_value_to_canonical_72[] = { 1, 2, 3, 5, 6, 7, 4, 0 };
7652 static const unsigned asn_MAP_value_from_canonical_72[] = { 7, 0, 1, 2, 6, 3, 4, 5 };
7653 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_72[] = {
7654     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 2 }, /* RANfunctionID */
7655     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* RICactionID */
7656     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 0 }, /* RICindicationSN */
7657     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 5, 0, 2 }, /* RICindicationHeader */
7658     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 6, -1, 1 }, /* RICindicationMessage */
7659     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 7, -2, 0 }, /* RICcallProcessID */
7660     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* RICindicationType */
7661     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
7662 };
7663 static asn_CHOICE_specifics_t asn_SPC_value_specs_72 = {
7664         sizeof(struct RICindication_IEs__value),
7665         offsetof(struct RICindication_IEs__value, _asn_ctx),
7666         offsetof(struct RICindication_IEs__value, present),
7667         sizeof(((struct RICindication_IEs__value *)0)->present),
7668         asn_MAP_value_tag2el_72,
7669         8,      /* Count of tags in the map */
7670         asn_MAP_value_to_canonical_72,
7671         asn_MAP_value_from_canonical_72,
7672         -1      /* Extensions start */
7673 };
7674 static /* Use -fall-defs-global to expose */
7675 asn_TYPE_descriptor_t asn_DEF_value_72 = {
7676         "value",
7677         "value",
7678         &asn_OP_OPEN_TYPE,
7679         0,      /* No effective tags (pointer) */
7680         0,      /* No effective tags (count) */
7681         0,      /* No tags (pointer) */
7682         0,      /* No tags (count) */
7683         { 0, 0, OPEN_TYPE_constraint },
7684         asn_MBR_value_72,
7685         8,      /* Elements count */
7686         &asn_SPC_value_specs_72 /* Additional specs */
7687 };
7688
7689 asn_TYPE_member_t asn_MBR_RICindication_IEs_69[] = {
7690         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, id),
7691                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7692                 0,
7693                 &asn_DEF_ProtocolIE_ID,
7694                 0,
7695                 { 0, &asn_PER_memb_id_constr_70,  memb_id_constraint_69 },
7696                 0, 0, /* No default value */
7697                 "id"
7698                 },
7699         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, criticality),
7700                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7701                 0,
7702                 &asn_DEF_Criticality,
7703                 select_RICindication_IEs_criticality_type,
7704                 { 0, &asn_PER_memb_criticality_constr_71,  memb_criticality_constraint_69 },
7705                 0, 0, /* No default value */
7706                 "criticality"
7707                 },
7708         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, value),
7709                 -1 /* Ambiguous tag (ANY?) */,
7710                 0,
7711                 &asn_DEF_value_72,
7712                 select_RICindication_IEs_value_type,
7713                 { 0, &asn_PER_memb_value_constr_72,  memb_value_constraint_69 },
7714                 0, 0, /* No default value */
7715                 "value"
7716                 },
7717 };
7718 static const ber_tlv_tag_t asn_DEF_RICindication_IEs_tags_69[] = {
7719         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7720 };
7721 static const asn_TYPE_tag2member_t asn_MAP_RICindication_IEs_tag2el_69[] = {
7722     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7723     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7724 };
7725 asn_SEQUENCE_specifics_t asn_SPC_RICindication_IEs_specs_69 = {
7726         sizeof(struct RICindication_IEs),
7727         offsetof(struct RICindication_IEs, _asn_ctx),
7728         asn_MAP_RICindication_IEs_tag2el_69,
7729         2,      /* Count of tags in the map */
7730         0, 0, 0,        /* Optional elements (not needed) */
7731         -1,     /* First extension addition */
7732 };
7733 asn_TYPE_descriptor_t asn_DEF_RICindication_IEs = {
7734         "RICindication-IEs",
7735         "RICindication-IEs",
7736         &asn_OP_SEQUENCE,
7737         asn_DEF_RICindication_IEs_tags_69,
7738         sizeof(asn_DEF_RICindication_IEs_tags_69)
7739                 /sizeof(asn_DEF_RICindication_IEs_tags_69[0]), /* 1 */
7740         asn_DEF_RICindication_IEs_tags_69,      /* Same as above */
7741         sizeof(asn_DEF_RICindication_IEs_tags_69)
7742                 /sizeof(asn_DEF_RICindication_IEs_tags_69[0]), /* 1 */
7743         { 0, 0, SEQUENCE_constraint },
7744         asn_MBR_RICindication_IEs_69,
7745         3,      /* Elements count */
7746         &asn_SPC_RICindication_IEs_specs_69     /* Additional specs */
7747 };
7748
7749 static asn_TYPE_member_t asn_MBR_value_76[] = {
7750         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICrequestID),
7751                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7752                 0,
7753                 &asn_DEF_RICrequestID,
7754                 0,
7755                 { 0, 0, 0 },
7756                 0, 0, /* No default value */
7757                 "RICrequestID"
7758                 },
7759         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RANfunctionID),
7760                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7761                 0,
7762                 &asn_DEF_RANfunctionID,
7763                 0,
7764                 { 0, 0, 0 },
7765                 0, 0, /* No default value */
7766                 "RANfunctionID"
7767                 },
7768         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcallProcessID),
7769                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7770                 0,
7771                 &asn_DEF_RICcallProcessID,
7772                 0,
7773                 { 0, 0, 0 },
7774                 0, 0, /* No default value */
7775                 "RICcallProcessID"
7776                 },
7777         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolHeader),
7778                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7779                 0,
7780                 &asn_DEF_RICcontrolHeader,
7781                 0,
7782                 { 0, 0, 0 },
7783                 0, 0, /* No default value */
7784                 "RICcontrolHeader"
7785                 },
7786         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolMessage),
7787                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7788                 0,
7789                 &asn_DEF_RICcontrolMessage,
7790                 0,
7791                 { 0, 0, 0 },
7792                 0, 0, /* No default value */
7793                 "RICcontrolMessage"
7794                 },
7795         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolAckRequest),
7796                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7797                 0,
7798                 &asn_DEF_RICcontrolAckRequest,
7799                 0,
7800                 { 0, 0, 0 },
7801                 0, 0, /* No default value */
7802                 "RICcontrolAckRequest"
7803                 },
7804 };
7805 static const unsigned asn_MAP_value_to_canonical_76[] = { 1, 2, 3, 4, 5, 0 };
7806 static const unsigned asn_MAP_value_from_canonical_76[] = { 5, 0, 1, 2, 3, 4 };
7807 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_76[] = {
7808     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
7809     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 2 }, /* RICcallProcessID */
7810     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 1 }, /* RICcontrolHeader */
7811     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -2, 0 }, /* RICcontrolMessage */
7812     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 5, 0, 0 }, /* RICcontrolAckRequest */
7813     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
7814 };
7815 static asn_CHOICE_specifics_t asn_SPC_value_specs_76 = {
7816         sizeof(struct RICcontrolRequest_IEs__value),
7817         offsetof(struct RICcontrolRequest_IEs__value, _asn_ctx),
7818         offsetof(struct RICcontrolRequest_IEs__value, present),
7819         sizeof(((struct RICcontrolRequest_IEs__value *)0)->present),
7820         asn_MAP_value_tag2el_76,
7821         6,      /* Count of tags in the map */
7822         asn_MAP_value_to_canonical_76,
7823         asn_MAP_value_from_canonical_76,
7824         -1      /* Extensions start */
7825 };
7826 static /* Use -fall-defs-global to expose */
7827 asn_TYPE_descriptor_t asn_DEF_value_76 = {
7828         "value",
7829         "value",
7830         &asn_OP_OPEN_TYPE,
7831         0,      /* No effective tags (pointer) */
7832         0,      /* No effective tags (count) */
7833         0,      /* No tags (pointer) */
7834         0,      /* No tags (count) */
7835         { 0, 0, OPEN_TYPE_constraint },
7836         asn_MBR_value_76,
7837         6,      /* Elements count */
7838         &asn_SPC_value_specs_76 /* Additional specs */
7839 };
7840
7841 asn_TYPE_member_t asn_MBR_RICcontrolRequest_IEs_73[] = {
7842         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, id),
7843                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7844                 0,
7845                 &asn_DEF_ProtocolIE_ID,
7846                 0,
7847                 { 0, &asn_PER_memb_id_constr_74,  memb_id_constraint_73 },
7848                 0, 0, /* No default value */
7849                 "id"
7850                 },
7851         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, criticality),
7852                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7853                 0,
7854                 &asn_DEF_Criticality,
7855                 select_RICcontrolRequest_IEs_criticality_type,
7856                 { 0, &asn_PER_memb_criticality_constr_75,  memb_criticality_constraint_73 },
7857                 0, 0, /* No default value */
7858                 "criticality"
7859                 },
7860         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, value),
7861                 -1 /* Ambiguous tag (ANY?) */,
7862                 0,
7863                 &asn_DEF_value_76,
7864                 select_RICcontrolRequest_IEs_value_type,
7865                 { 0, &asn_PER_memb_value_constr_76,  memb_value_constraint_73 },
7866                 0, 0, /* No default value */
7867                 "value"
7868                 },
7869 };
7870 static const ber_tlv_tag_t asn_DEF_RICcontrolRequest_IEs_tags_73[] = {
7871         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7872 };
7873 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolRequest_IEs_tag2el_73[] = {
7874     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7875     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7876 };
7877 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolRequest_IEs_specs_73 = {
7878         sizeof(struct RICcontrolRequest_IEs),
7879         offsetof(struct RICcontrolRequest_IEs, _asn_ctx),
7880         asn_MAP_RICcontrolRequest_IEs_tag2el_73,
7881         2,      /* Count of tags in the map */
7882         0, 0, 0,        /* Optional elements (not needed) */
7883         -1,     /* First extension addition */
7884 };
7885 asn_TYPE_descriptor_t asn_DEF_RICcontrolRequest_IEs = {
7886         "RICcontrolRequest-IEs",
7887         "RICcontrolRequest-IEs",
7888         &asn_OP_SEQUENCE,
7889         asn_DEF_RICcontrolRequest_IEs_tags_73,
7890         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_73)
7891                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_73[0]), /* 1 */
7892         asn_DEF_RICcontrolRequest_IEs_tags_73,  /* Same as above */
7893         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_73)
7894                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_73[0]), /* 1 */
7895         { 0, 0, SEQUENCE_constraint },
7896         asn_MBR_RICcontrolRequest_IEs_73,
7897         3,      /* Elements count */
7898         &asn_SPC_RICcontrolRequest_IEs_specs_73 /* Additional specs */
7899 };
7900
7901 static asn_TYPE_member_t asn_MBR_value_80[] = {
7902         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICrequestID),
7903                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7904                 0,
7905                 &asn_DEF_RICrequestID,
7906                 0,
7907                 { 0, 0, 0 },
7908                 0, 0, /* No default value */
7909                 "RICrequestID"
7910                 },
7911         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RANfunctionID),
7912                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7913                 0,
7914                 &asn_DEF_RANfunctionID,
7915                 0,
7916                 { 0, 0, 0 },
7917                 0, 0, /* No default value */
7918                 "RANfunctionID"
7919                 },
7920         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcallProcessID),
7921                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7922                 0,
7923                 &asn_DEF_RICcallProcessID,
7924                 0,
7925                 { 0, 0, 0 },
7926                 0, 0, /* No default value */
7927                 "RICcallProcessID"
7928                 },
7929         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolStatus),
7930                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7931                 0,
7932                 &asn_DEF_RICcontrolStatus,
7933                 0,
7934                 { 0, 0, 0 },
7935                 0, 0, /* No default value */
7936                 "RICcontrolStatus"
7937                 },
7938         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolOutcome),
7939                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
7940                 0,
7941                 &asn_DEF_RICcontrolOutcome,
7942                 0,
7943                 { 0, 0, 0 },
7944                 0, 0, /* No default value */
7945                 "RICcontrolOutcome"
7946                 },
7947 };
7948 static const unsigned asn_MAP_value_to_canonical_80[] = { 1, 2, 4, 3, 0 };
7949 static const unsigned asn_MAP_value_from_canonical_80[] = { 4, 0, 1, 3, 2 };
7950 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_80[] = {
7951     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
7952     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
7953     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
7954     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 3, 0, 0 }, /* RICcontrolStatus */
7955     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
7956 };
7957 static asn_CHOICE_specifics_t asn_SPC_value_specs_80 = {
7958         sizeof(struct RICcontrolAcknowledge_IEs__value),
7959         offsetof(struct RICcontrolAcknowledge_IEs__value, _asn_ctx),
7960         offsetof(struct RICcontrolAcknowledge_IEs__value, present),
7961         sizeof(((struct RICcontrolAcknowledge_IEs__value *)0)->present),
7962         asn_MAP_value_tag2el_80,
7963         5,      /* Count of tags in the map */
7964         asn_MAP_value_to_canonical_80,
7965         asn_MAP_value_from_canonical_80,
7966         -1      /* Extensions start */
7967 };
7968 static /* Use -fall-defs-global to expose */
7969 asn_TYPE_descriptor_t asn_DEF_value_80 = {
7970         "value",
7971         "value",
7972         &asn_OP_OPEN_TYPE,
7973         0,      /* No effective tags (pointer) */
7974         0,      /* No effective tags (count) */
7975         0,      /* No tags (pointer) */
7976         0,      /* No tags (count) */
7977         { 0, 0, OPEN_TYPE_constraint },
7978         asn_MBR_value_80,
7979         5,      /* Elements count */
7980         &asn_SPC_value_specs_80 /* Additional specs */
7981 };
7982
7983 asn_TYPE_member_t asn_MBR_RICcontrolAcknowledge_IEs_77[] = {
7984         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, id),
7985                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7986                 0,
7987                 &asn_DEF_ProtocolIE_ID,
7988                 0,
7989                 { 0, &asn_PER_memb_id_constr_78,  memb_id_constraint_77 },
7990                 0, 0, /* No default value */
7991                 "id"
7992                 },
7993         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, criticality),
7994                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7995                 0,
7996                 &asn_DEF_Criticality,
7997                 select_RICcontrolAcknowledge_IEs_criticality_type,
7998                 { 0, &asn_PER_memb_criticality_constr_79,  memb_criticality_constraint_77 },
7999                 0, 0, /* No default value */
8000                 "criticality"
8001                 },
8002         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, value),
8003                 -1 /* Ambiguous tag (ANY?) */,
8004                 0,
8005                 &asn_DEF_value_80,
8006                 select_RICcontrolAcknowledge_IEs_value_type,
8007                 { 0, &asn_PER_memb_value_constr_80,  memb_value_constraint_77 },
8008                 0, 0, /* No default value */
8009                 "value"
8010                 },
8011 };
8012 static const ber_tlv_tag_t asn_DEF_RICcontrolAcknowledge_IEs_tags_77[] = {
8013         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8014 };
8015 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolAcknowledge_IEs_tag2el_77[] = {
8016     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8017     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8018 };
8019 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolAcknowledge_IEs_specs_77 = {
8020         sizeof(struct RICcontrolAcknowledge_IEs),
8021         offsetof(struct RICcontrolAcknowledge_IEs, _asn_ctx),
8022         asn_MAP_RICcontrolAcknowledge_IEs_tag2el_77,
8023         2,      /* Count of tags in the map */
8024         0, 0, 0,        /* Optional elements (not needed) */
8025         -1,     /* First extension addition */
8026 };
8027 asn_TYPE_descriptor_t asn_DEF_RICcontrolAcknowledge_IEs = {
8028         "RICcontrolAcknowledge-IEs",
8029         "RICcontrolAcknowledge-IEs",
8030         &asn_OP_SEQUENCE,
8031         asn_DEF_RICcontrolAcknowledge_IEs_tags_77,
8032         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_77)
8033                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_77[0]), /* 1 */
8034         asn_DEF_RICcontrolAcknowledge_IEs_tags_77,      /* Same as above */
8035         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_77)
8036                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_77[0]), /* 1 */
8037         { 0, 0, SEQUENCE_constraint },
8038         asn_MBR_RICcontrolAcknowledge_IEs_77,
8039         3,      /* Elements count */
8040         &asn_SPC_RICcontrolAcknowledge_IEs_specs_77     /* Additional specs */
8041 };
8042
8043 static asn_TYPE_member_t asn_MBR_value_84[] = {
8044         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICrequestID),
8045                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8046                 0,
8047                 &asn_DEF_RICrequestID,
8048                 0,
8049                 { 0, 0, 0 },
8050                 0, 0, /* No default value */
8051                 "RICrequestID"
8052                 },
8053         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RANfunctionID),
8054                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8055                 0,
8056                 &asn_DEF_RANfunctionID,
8057                 0,
8058                 { 0, 0, 0 },
8059                 0, 0, /* No default value */
8060                 "RANfunctionID"
8061                 },
8062         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcallProcessID),
8063                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
8064                 0,
8065                 &asn_DEF_RICcallProcessID,
8066                 0,
8067                 { 0, 0, 0 },
8068                 0, 0, /* No default value */
8069                 "RICcallProcessID"
8070                 },
8071         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.Cause),
8072                 -1 /* Ambiguous tag (CHOICE?) */,
8073                 0,
8074                 &asn_DEF_Cause,
8075                 0,
8076                 { 0, 0, 0 },
8077                 0, 0, /* No default value */
8078                 "Cause"
8079                 },
8080         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcontrolOutcome),
8081                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
8082                 0,
8083                 &asn_DEF_RICcontrolOutcome,
8084                 0,
8085                 { 0, 0, 0 },
8086                 0, 0, /* No default value */
8087                 "RICcontrolOutcome"
8088                 },
8089 };
8090 static const unsigned asn_MAP_value_to_canonical_84[] = { 1, 2, 4, 0, 3 };
8091 static const unsigned asn_MAP_value_from_canonical_84[] = { 3, 0, 1, 4, 2 };
8092 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_84[] = {
8093     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
8094     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
8095     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
8096     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* RICrequestID */
8097     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 3, 0, 0 }, /* ricRequest */
8098     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* ricService */
8099     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 3, 0, 0 }, /* transport */
8100     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
8101     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* misc */
8102 };
8103 static asn_CHOICE_specifics_t asn_SPC_value_specs_84 = {
8104         sizeof(struct RICcontrolFailure_IEs__value),
8105         offsetof(struct RICcontrolFailure_IEs__value, _asn_ctx),
8106         offsetof(struct RICcontrolFailure_IEs__value, present),
8107         sizeof(((struct RICcontrolFailure_IEs__value *)0)->present),
8108         asn_MAP_value_tag2el_84,
8109         9,      /* Count of tags in the map */
8110         asn_MAP_value_to_canonical_84,
8111         asn_MAP_value_from_canonical_84,
8112         -1      /* Extensions start */
8113 };
8114 static /* Use -fall-defs-global to expose */
8115 asn_TYPE_descriptor_t asn_DEF_value_84 = {
8116         "value",
8117         "value",
8118         &asn_OP_OPEN_TYPE,
8119         0,      /* No effective tags (pointer) */
8120         0,      /* No effective tags (count) */
8121         0,      /* No tags (pointer) */
8122         0,      /* No tags (count) */
8123         { 0, 0, OPEN_TYPE_constraint },
8124         asn_MBR_value_84,
8125         5,      /* Elements count */
8126         &asn_SPC_value_specs_84 /* Additional specs */
8127 };
8128
8129 asn_TYPE_member_t asn_MBR_RICcontrolFailure_IEs_81[] = {
8130         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, id),
8131                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8132                 0,
8133                 &asn_DEF_ProtocolIE_ID,
8134                 0,
8135                 { 0, &asn_PER_memb_id_constr_82,  memb_id_constraint_81 },
8136                 0, 0, /* No default value */
8137                 "id"
8138                 },
8139         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, criticality),
8140                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8141                 0,
8142                 &asn_DEF_Criticality,
8143                 select_RICcontrolFailure_IEs_criticality_type,
8144                 { 0, &asn_PER_memb_criticality_constr_83,  memb_criticality_constraint_81 },
8145                 0, 0, /* No default value */
8146                 "criticality"
8147                 },
8148         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, value),
8149                 -1 /* Ambiguous tag (ANY?) */,
8150                 0,
8151                 &asn_DEF_value_84,
8152                 select_RICcontrolFailure_IEs_value_type,
8153                 { 0, &asn_PER_memb_value_constr_84,  memb_value_constraint_81 },
8154                 0, 0, /* No default value */
8155                 "value"
8156                 },
8157 };
8158 static const ber_tlv_tag_t asn_DEF_RICcontrolFailure_IEs_tags_81[] = {
8159         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8160 };
8161 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolFailure_IEs_tag2el_81[] = {
8162     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8163     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8164 };
8165 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolFailure_IEs_specs_81 = {
8166         sizeof(struct RICcontrolFailure_IEs),
8167         offsetof(struct RICcontrolFailure_IEs, _asn_ctx),
8168         asn_MAP_RICcontrolFailure_IEs_tag2el_81,
8169         2,      /* Count of tags in the map */
8170         0, 0, 0,        /* Optional elements (not needed) */
8171         -1,     /* First extension addition */
8172 };
8173 asn_TYPE_descriptor_t asn_DEF_RICcontrolFailure_IEs = {
8174         "RICcontrolFailure-IEs",
8175         "RICcontrolFailure-IEs",
8176         &asn_OP_SEQUENCE,
8177         asn_DEF_RICcontrolFailure_IEs_tags_81,
8178         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_81)
8179                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_81[0]), /* 1 */
8180         asn_DEF_RICcontrolFailure_IEs_tags_81,  /* Same as above */
8181         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_81)
8182                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_81[0]), /* 1 */
8183         { 0, 0, SEQUENCE_constraint },
8184         asn_MBR_RICcontrolFailure_IEs_81,
8185         3,      /* Elements count */
8186         &asn_SPC_RICcontrolFailure_IEs_specs_81 /* Additional specs */
8187 };
8188
8189 static asn_TYPE_member_t asn_MBR_value_88[] = {
8190         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RICrequestID),
8191                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8192                 0,
8193                 &asn_DEF_RICrequestID,
8194                 0,
8195                 { 0, 0, 0 },
8196                 0, 0, /* No default value */
8197                 "RICrequestID"
8198                 },
8199         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RANfunctionID),
8200                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8201                 0,
8202                 &asn_DEF_RANfunctionID,
8203                 0,
8204                 { 0, 0, 0 },
8205                 0, 0, /* No default value */
8206                 "RANfunctionID"
8207                 },
8208         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.Cause),
8209                 -1 /* Ambiguous tag (CHOICE?) */,
8210                 0,
8211                 &asn_DEF_Cause,
8212                 0,
8213                 { 0, 0, 0 },
8214                 0, 0, /* No default value */
8215                 "Cause"
8216                 },
8217         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.CriticalityDiagnostics),
8218                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8219                 0,
8220                 &asn_DEF_CriticalityDiagnostics,
8221                 0,
8222                 { 0, 0, 0 },
8223                 0, 0, /* No default value */
8224                 "CriticalityDiagnostics"
8225                 },
8226 };
8227 static const unsigned asn_MAP_value_to_canonical_88[] = { 1, 0, 3, 2 };
8228 static const unsigned asn_MAP_value_from_canonical_88[] = { 1, 0, 3, 2 };
8229 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_88[] = {
8230     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
8231     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
8232     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
8233     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
8234     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
8235     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
8236     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
8237     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
8238 };
8239 static asn_CHOICE_specifics_t asn_SPC_value_specs_88 = {
8240         sizeof(struct ErrorIndication_IEs__value),
8241         offsetof(struct ErrorIndication_IEs__value, _asn_ctx),
8242         offsetof(struct ErrorIndication_IEs__value, present),
8243         sizeof(((struct ErrorIndication_IEs__value *)0)->present),
8244         asn_MAP_value_tag2el_88,
8245         8,      /* Count of tags in the map */
8246         asn_MAP_value_to_canonical_88,
8247         asn_MAP_value_from_canonical_88,
8248         -1      /* Extensions start */
8249 };
8250 static /* Use -fall-defs-global to expose */
8251 asn_TYPE_descriptor_t asn_DEF_value_88 = {
8252         "value",
8253         "value",
8254         &asn_OP_OPEN_TYPE,
8255         0,      /* No effective tags (pointer) */
8256         0,      /* No effective tags (count) */
8257         0,      /* No tags (pointer) */
8258         0,      /* No tags (count) */
8259         { 0, 0, OPEN_TYPE_constraint },
8260         asn_MBR_value_88,
8261         4,      /* Elements count */
8262         &asn_SPC_value_specs_88 /* Additional specs */
8263 };
8264
8265 asn_TYPE_member_t asn_MBR_ErrorIndication_IEs_85[] = {
8266         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, id),
8267                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8268                 0,
8269                 &asn_DEF_ProtocolIE_ID,
8270                 0,
8271                 { 0, &asn_PER_memb_id_constr_86,  memb_id_constraint_85 },
8272                 0, 0, /* No default value */
8273                 "id"
8274                 },
8275         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, criticality),
8276                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8277                 0,
8278                 &asn_DEF_Criticality,
8279                 select_ErrorIndication_IEs_criticality_type,
8280                 { 0, &asn_PER_memb_criticality_constr_87,  memb_criticality_constraint_85 },
8281                 0, 0, /* No default value */
8282                 "criticality"
8283                 },
8284         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, value),
8285                 -1 /* Ambiguous tag (ANY?) */,
8286                 0,
8287                 &asn_DEF_value_88,
8288                 select_ErrorIndication_IEs_value_type,
8289                 { 0, &asn_PER_memb_value_constr_88,  memb_value_constraint_85 },
8290                 0, 0, /* No default value */
8291                 "value"
8292                 },
8293 };
8294 static const ber_tlv_tag_t asn_DEF_ErrorIndication_IEs_tags_85[] = {
8295         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8296 };
8297 static const asn_TYPE_tag2member_t asn_MAP_ErrorIndication_IEs_tag2el_85[] = {
8298     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8299     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8300 };
8301 asn_SEQUENCE_specifics_t asn_SPC_ErrorIndication_IEs_specs_85 = {
8302         sizeof(struct ErrorIndication_IEs),
8303         offsetof(struct ErrorIndication_IEs, _asn_ctx),
8304         asn_MAP_ErrorIndication_IEs_tag2el_85,
8305         2,      /* Count of tags in the map */
8306         0, 0, 0,        /* Optional elements (not needed) */
8307         -1,     /* First extension addition */
8308 };
8309 asn_TYPE_descriptor_t asn_DEF_ErrorIndication_IEs = {
8310         "ErrorIndication-IEs",
8311         "ErrorIndication-IEs",
8312         &asn_OP_SEQUENCE,
8313         asn_DEF_ErrorIndication_IEs_tags_85,
8314         sizeof(asn_DEF_ErrorIndication_IEs_tags_85)
8315                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_85[0]), /* 1 */
8316         asn_DEF_ErrorIndication_IEs_tags_85,    /* Same as above */
8317         sizeof(asn_DEF_ErrorIndication_IEs_tags_85)
8318                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_85[0]), /* 1 */
8319         { 0, 0, SEQUENCE_constraint },
8320         asn_MBR_ErrorIndication_IEs_85,
8321         3,      /* Elements count */
8322         &asn_SPC_ErrorIndication_IEs_specs_85   /* Additional specs */
8323 };
8324
8325 static asn_TYPE_member_t asn_MBR_value_92[] = {
8326         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.GlobalE2node_ID),
8327                 -1 /* Ambiguous tag (CHOICE?) */,
8328                 0,
8329                 &asn_DEF_GlobalE2node_ID,
8330                 0,
8331                 { 0, 0, 0 },
8332                 0, 0, /* No default value */
8333                 "GlobalE2node-ID"
8334                 },
8335         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.RANfunctions_List),
8336                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8337                 0,
8338                 &asn_DEF_RANfunctions_List,
8339                 0,
8340                 { 0, 0, 0 },
8341                 0, 0, /* No default value */
8342                 "RANfunctions-List"
8343                 },
8344         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.E2nodeComponentConfigUpdate_List),
8345                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8346                 0,
8347                 &asn_DEF_E2nodeComponentConfigUpdate_List,
8348                 0,
8349                 { 0, 0, 0 },
8350                 0, 0, /* No default value */
8351                 "E2nodeComponentConfigUpdate-List"
8352                 },
8353 };
8354 static const unsigned asn_MAP_value_to_canonical_92[] = { 1, 2, 0 };
8355 static const unsigned asn_MAP_value_from_canonical_92[] = { 2, 0, 1 };
8356 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_92[] = {
8357     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 1 }, /* RANfunctions-List */
8358     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 }, /* E2nodeComponentConfigUpdate-List */
8359     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gNB */
8360     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* en-gNB */
8361     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* ng-eNB */
8362     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 } /* eNB */
8363 };
8364 static asn_CHOICE_specifics_t asn_SPC_value_specs_92 = {
8365         sizeof(struct E2setupRequestIEs__value),
8366         offsetof(struct E2setupRequestIEs__value, _asn_ctx),
8367         offsetof(struct E2setupRequestIEs__value, present),
8368         sizeof(((struct E2setupRequestIEs__value *)0)->present),
8369         asn_MAP_value_tag2el_92,
8370         6,      /* Count of tags in the map */
8371         asn_MAP_value_to_canonical_92,
8372         asn_MAP_value_from_canonical_92,
8373         -1      /* Extensions start */
8374 };
8375 static /* Use -fall-defs-global to expose */
8376 asn_TYPE_descriptor_t asn_DEF_value_92 = {
8377         "value",
8378         "value",
8379         &asn_OP_OPEN_TYPE,
8380         0,      /* No effective tags (pointer) */
8381         0,      /* No effective tags (count) */
8382         0,      /* No tags (pointer) */
8383         0,      /* No tags (count) */
8384         { 0, 0, OPEN_TYPE_constraint },
8385         asn_MBR_value_92,
8386         3,      /* Elements count */
8387         &asn_SPC_value_specs_92 /* Additional specs */
8388 };
8389
8390 asn_TYPE_member_t asn_MBR_E2setupRequestIEs_89[] = {
8391         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, id),
8392                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8393                 0,
8394                 &asn_DEF_ProtocolIE_ID,
8395                 0,
8396                 { 0, &asn_PER_memb_id_constr_90,  memb_id_constraint_89 },
8397                 0, 0, /* No default value */
8398                 "id"
8399                 },
8400         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, criticality),
8401                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8402                 0,
8403                 &asn_DEF_Criticality,
8404                 select_E2setupRequestIEs_criticality_type,
8405                 { 0, &asn_PER_memb_criticality_constr_91,  memb_criticality_constraint_89 },
8406                 0, 0, /* No default value */
8407                 "criticality"
8408                 },
8409         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, value),
8410                 -1 /* Ambiguous tag (ANY?) */,
8411                 0,
8412                 &asn_DEF_value_92,
8413                 select_E2setupRequestIEs_value_type,
8414                 { 0, &asn_PER_memb_value_constr_92,  memb_value_constraint_89 },
8415                 0, 0, /* No default value */
8416                 "value"
8417                 },
8418 };
8419 static const ber_tlv_tag_t asn_DEF_E2setupRequestIEs_tags_89[] = {
8420         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8421 };
8422 static const asn_TYPE_tag2member_t asn_MAP_E2setupRequestIEs_tag2el_89[] = {
8423     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8424     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8425 };
8426 asn_SEQUENCE_specifics_t asn_SPC_E2setupRequestIEs_specs_89 = {
8427         sizeof(struct E2setupRequestIEs),
8428         offsetof(struct E2setupRequestIEs, _asn_ctx),
8429         asn_MAP_E2setupRequestIEs_tag2el_89,
8430         2,      /* Count of tags in the map */
8431         0, 0, 0,        /* Optional elements (not needed) */
8432         -1,     /* First extension addition */
8433 };
8434 asn_TYPE_descriptor_t asn_DEF_E2setupRequestIEs = {
8435         "E2setupRequestIEs",
8436         "E2setupRequestIEs",
8437         &asn_OP_SEQUENCE,
8438         asn_DEF_E2setupRequestIEs_tags_89,
8439         sizeof(asn_DEF_E2setupRequestIEs_tags_89)
8440                 /sizeof(asn_DEF_E2setupRequestIEs_tags_89[0]), /* 1 */
8441         asn_DEF_E2setupRequestIEs_tags_89,      /* Same as above */
8442         sizeof(asn_DEF_E2setupRequestIEs_tags_89)
8443                 /sizeof(asn_DEF_E2setupRequestIEs_tags_89[0]), /* 1 */
8444         { 0, 0, SEQUENCE_constraint },
8445         asn_MBR_E2setupRequestIEs_89,
8446         3,      /* Elements count */
8447         &asn_SPC_E2setupRequestIEs_specs_89     /* Additional specs */
8448 };
8449
8450 static asn_TYPE_member_t asn_MBR_value_96[] = {
8451         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.GlobalRIC_ID),
8452                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8453                 0,
8454                 &asn_DEF_GlobalRIC_ID,
8455                 0,
8456                 { 0, 0, 0 },
8457                 0, 0, /* No default value */
8458                 "GlobalRIC-ID"
8459                 },
8460         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsID_List),
8461                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8462                 0,
8463                 &asn_DEF_RANfunctionsID_List,
8464                 0,
8465                 { 0, 0, 0 },
8466                 0, 0, /* No default value */
8467                 "RANfunctionsID-List"
8468                 },
8469         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsIDcause_List),
8470                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8471                 0,
8472                 &asn_DEF_RANfunctionsIDcause_List,
8473                 0,
8474                 { 0, 0, 0 },
8475                 0, 0, /* No default value */
8476                 "RANfunctionsIDcause-List"
8477                 },
8478         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.E2nodeComponentConfigUpdateAck_List),
8479                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8480                 0,
8481                 &asn_DEF_E2nodeComponentConfigUpdateAck_List,
8482                 0,
8483                 { 0, 0, 0 },
8484                 0, 0, /* No default value */
8485                 "E2nodeComponentConfigUpdateAck-List"
8486                 },
8487 };
8488 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_96[] = {
8489     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 3 }, /* GlobalRIC-ID */
8490     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 2 }, /* RANfunctionsID-List */
8491     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -2, 1 }, /* RANfunctionsIDcause-List */
8492     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -3, 0 } /* E2nodeComponentConfigUpdateAck-List */
8493 };
8494 static asn_CHOICE_specifics_t asn_SPC_value_specs_96 = {
8495         sizeof(struct E2setupResponseIEs__value),
8496         offsetof(struct E2setupResponseIEs__value, _asn_ctx),
8497         offsetof(struct E2setupResponseIEs__value, present),
8498         sizeof(((struct E2setupResponseIEs__value *)0)->present),
8499         asn_MAP_value_tag2el_96,
8500         4,      /* Count of tags in the map */
8501         0, 0,
8502         -1      /* Extensions start */
8503 };
8504 static /* Use -fall-defs-global to expose */
8505 asn_TYPE_descriptor_t asn_DEF_value_96 = {
8506         "value",
8507         "value",
8508         &asn_OP_OPEN_TYPE,
8509         0,      /* No effective tags (pointer) */
8510         0,      /* No effective tags (count) */
8511         0,      /* No tags (pointer) */
8512         0,      /* No tags (count) */
8513         { 0, 0, OPEN_TYPE_constraint },
8514         asn_MBR_value_96,
8515         4,      /* Elements count */
8516         &asn_SPC_value_specs_96 /* Additional specs */
8517 };
8518
8519 asn_TYPE_member_t asn_MBR_E2setupResponseIEs_93[] = {
8520         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, id),
8521                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8522                 0,
8523                 &asn_DEF_ProtocolIE_ID,
8524                 0,
8525                 { 0, &asn_PER_memb_id_constr_94,  memb_id_constraint_93 },
8526                 0, 0, /* No default value */
8527                 "id"
8528                 },
8529         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, criticality),
8530                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8531                 0,
8532                 &asn_DEF_Criticality,
8533                 select_E2setupResponseIEs_criticality_type,
8534                 { 0, &asn_PER_memb_criticality_constr_95,  memb_criticality_constraint_93 },
8535                 0, 0, /* No default value */
8536                 "criticality"
8537                 },
8538         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, value),
8539                 -1 /* Ambiguous tag (ANY?) */,
8540                 0,
8541                 &asn_DEF_value_96,
8542                 select_E2setupResponseIEs_value_type,
8543                 { 0, &asn_PER_memb_value_constr_96,  memb_value_constraint_93 },
8544                 0, 0, /* No default value */
8545                 "value"
8546                 },
8547 };
8548 static const ber_tlv_tag_t asn_DEF_E2setupResponseIEs_tags_93[] = {
8549         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8550 };
8551 static const asn_TYPE_tag2member_t asn_MAP_E2setupResponseIEs_tag2el_93[] = {
8552     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8553     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8554 };
8555 asn_SEQUENCE_specifics_t asn_SPC_E2setupResponseIEs_specs_93 = {
8556         sizeof(struct E2setupResponseIEs),
8557         offsetof(struct E2setupResponseIEs, _asn_ctx),
8558         asn_MAP_E2setupResponseIEs_tag2el_93,
8559         2,      /* Count of tags in the map */
8560         0, 0, 0,        /* Optional elements (not needed) */
8561         -1,     /* First extension addition */
8562 };
8563 asn_TYPE_descriptor_t asn_DEF_E2setupResponseIEs = {
8564         "E2setupResponseIEs",
8565         "E2setupResponseIEs",
8566         &asn_OP_SEQUENCE,
8567         asn_DEF_E2setupResponseIEs_tags_93,
8568         sizeof(asn_DEF_E2setupResponseIEs_tags_93)
8569                 /sizeof(asn_DEF_E2setupResponseIEs_tags_93[0]), /* 1 */
8570         asn_DEF_E2setupResponseIEs_tags_93,     /* Same as above */
8571         sizeof(asn_DEF_E2setupResponseIEs_tags_93)
8572                 /sizeof(asn_DEF_E2setupResponseIEs_tags_93[0]), /* 1 */
8573         { 0, 0, SEQUENCE_constraint },
8574         asn_MBR_E2setupResponseIEs_93,
8575         3,      /* Elements count */
8576         &asn_SPC_E2setupResponseIEs_specs_93    /* Additional specs */
8577 };
8578
8579 static asn_TYPE_member_t asn_MBR_value_100[] = {
8580         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.Cause),
8581                 -1 /* Ambiguous tag (CHOICE?) */,
8582                 0,
8583                 &asn_DEF_Cause,
8584                 0,
8585                 { 0, 0, 0 },
8586                 0, 0, /* No default value */
8587                 "Cause"
8588                 },
8589         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.TimeToWait),
8590                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8591                 0,
8592                 &asn_DEF_TimeToWait,
8593                 0,
8594                 { 0, 0, 0 },
8595                 0, 0, /* No default value */
8596                 "TimeToWait"
8597                 },
8598         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.CriticalityDiagnostics),
8599                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8600                 0,
8601                 &asn_DEF_CriticalityDiagnostics,
8602                 0,
8603                 { 0, 0, 0 },
8604                 0, 0, /* No default value */
8605                 "CriticalityDiagnostics"
8606                 },
8607         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.TNLinformation),
8608                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8609                 0,
8610                 &asn_DEF_TNLinformation,
8611                 0,
8612                 { 0, 0, 0 },
8613                 0, 0, /* No default value */
8614                 "TNLinformation"
8615                 },
8616 };
8617 static const unsigned asn_MAP_value_to_canonical_100[] = { 1, 2, 3, 0 };
8618 static const unsigned asn_MAP_value_from_canonical_100[] = { 3, 0, 1, 2 };
8619 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_100[] = {
8620     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
8621     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 1 }, /* CriticalityDiagnostics */
8622     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* TNLinformation */
8623     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
8624     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
8625     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
8626     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
8627     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
8628 };
8629 static asn_CHOICE_specifics_t asn_SPC_value_specs_100 = {
8630         sizeof(struct E2setupFailureIEs__value),
8631         offsetof(struct E2setupFailureIEs__value, _asn_ctx),
8632         offsetof(struct E2setupFailureIEs__value, present),
8633         sizeof(((struct E2setupFailureIEs__value *)0)->present),
8634         asn_MAP_value_tag2el_100,
8635         8,      /* Count of tags in the map */
8636         asn_MAP_value_to_canonical_100,
8637         asn_MAP_value_from_canonical_100,
8638         -1      /* Extensions start */
8639 };
8640 static /* Use -fall-defs-global to expose */
8641 asn_TYPE_descriptor_t asn_DEF_value_100 = {
8642         "value",
8643         "value",
8644         &asn_OP_OPEN_TYPE,
8645         0,      /* No effective tags (pointer) */
8646         0,      /* No effective tags (count) */
8647         0,      /* No tags (pointer) */
8648         0,      /* No tags (count) */
8649         { 0, 0, OPEN_TYPE_constraint },
8650         asn_MBR_value_100,
8651         4,      /* Elements count */
8652         &asn_SPC_value_specs_100        /* Additional specs */
8653 };
8654
8655 asn_TYPE_member_t asn_MBR_E2setupFailureIEs_97[] = {
8656         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, id),
8657                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8658                 0,
8659                 &asn_DEF_ProtocolIE_ID,
8660                 0,
8661                 { 0, &asn_PER_memb_id_constr_98,  memb_id_constraint_97 },
8662                 0, 0, /* No default value */
8663                 "id"
8664                 },
8665         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, criticality),
8666                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8667                 0,
8668                 &asn_DEF_Criticality,
8669                 select_E2setupFailureIEs_criticality_type,
8670                 { 0, &asn_PER_memb_criticality_constr_99,  memb_criticality_constraint_97 },
8671                 0, 0, /* No default value */
8672                 "criticality"
8673                 },
8674         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, value),
8675                 -1 /* Ambiguous tag (ANY?) */,
8676                 0,
8677                 &asn_DEF_value_100,
8678                 select_E2setupFailureIEs_value_type,
8679                 { 0, &asn_PER_memb_value_constr_100,  memb_value_constraint_97 },
8680                 0, 0, /* No default value */
8681                 "value"
8682                 },
8683 };
8684 static const ber_tlv_tag_t asn_DEF_E2setupFailureIEs_tags_97[] = {
8685         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8686 };
8687 static const asn_TYPE_tag2member_t asn_MAP_E2setupFailureIEs_tag2el_97[] = {
8688     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8689     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8690 };
8691 asn_SEQUENCE_specifics_t asn_SPC_E2setupFailureIEs_specs_97 = {
8692         sizeof(struct E2setupFailureIEs),
8693         offsetof(struct E2setupFailureIEs, _asn_ctx),
8694         asn_MAP_E2setupFailureIEs_tag2el_97,
8695         2,      /* Count of tags in the map */
8696         0, 0, 0,        /* Optional elements (not needed) */
8697         -1,     /* First extension addition */
8698 };
8699 asn_TYPE_descriptor_t asn_DEF_E2setupFailureIEs = {
8700         "E2setupFailureIEs",
8701         "E2setupFailureIEs",
8702         &asn_OP_SEQUENCE,
8703         asn_DEF_E2setupFailureIEs_tags_97,
8704         sizeof(asn_DEF_E2setupFailureIEs_tags_97)
8705                 /sizeof(asn_DEF_E2setupFailureIEs_tags_97[0]), /* 1 */
8706         asn_DEF_E2setupFailureIEs_tags_97,      /* Same as above */
8707         sizeof(asn_DEF_E2setupFailureIEs_tags_97)
8708                 /sizeof(asn_DEF_E2setupFailureIEs_tags_97[0]), /* 1 */
8709         { 0, 0, SEQUENCE_constraint },
8710         asn_MBR_E2setupFailureIEs_97,
8711         3,      /* Elements count */
8712         &asn_SPC_E2setupFailureIEs_specs_97     /* Additional specs */
8713 };
8714
8715 static asn_TYPE_member_t asn_MBR_value_104[] = {
8716         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_IEs__value, choice.E2connectionUpdate_List),
8717                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8718                 0,
8719                 &asn_DEF_E2connectionUpdate_List,
8720                 0,
8721                 { 0, 0, 0 },
8722                 0, 0, /* No default value */
8723                 "E2connectionUpdate-List"
8724                 },
8725         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_IEs__value, choice.E2connectionUpdateRemove_List),
8726                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8727                 0,
8728                 &asn_DEF_E2connectionUpdateRemove_List,
8729                 0,
8730                 { 0, 0, 0 },
8731                 0, 0, /* No default value */
8732                 "E2connectionUpdateRemove-List"
8733                 },
8734 };
8735 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_104[] = {
8736     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* E2connectionUpdate-List */
8737     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* E2connectionUpdateRemove-List */
8738 };
8739 static asn_CHOICE_specifics_t asn_SPC_value_specs_104 = {
8740         sizeof(struct E2connectionUpdate_IEs__value),
8741         offsetof(struct E2connectionUpdate_IEs__value, _asn_ctx),
8742         offsetof(struct E2connectionUpdate_IEs__value, present),
8743         sizeof(((struct E2connectionUpdate_IEs__value *)0)->present),
8744         asn_MAP_value_tag2el_104,
8745         2,      /* Count of tags in the map */
8746         0, 0,
8747         -1      /* Extensions start */
8748 };
8749 static /* Use -fall-defs-global to expose */
8750 asn_TYPE_descriptor_t asn_DEF_value_104 = {
8751         "value",
8752         "value",
8753         &asn_OP_OPEN_TYPE,
8754         0,      /* No effective tags (pointer) */
8755         0,      /* No effective tags (count) */
8756         0,      /* No tags (pointer) */
8757         0,      /* No tags (count) */
8758         { 0, 0, OPEN_TYPE_constraint },
8759         asn_MBR_value_104,
8760         2,      /* Elements count */
8761         &asn_SPC_value_specs_104        /* Additional specs */
8762 };
8763
8764 asn_TYPE_member_t asn_MBR_E2connectionUpdate_IEs_101[] = {
8765         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_IEs, id),
8766                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8767                 0,
8768                 &asn_DEF_ProtocolIE_ID,
8769                 0,
8770                 { 0, &asn_PER_memb_id_constr_102,  memb_id_constraint_101 },
8771                 0, 0, /* No default value */
8772                 "id"
8773                 },
8774         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_IEs, criticality),
8775                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8776                 0,
8777                 &asn_DEF_Criticality,
8778                 select_E2connectionUpdate_IEs_criticality_type,
8779                 { 0, &asn_PER_memb_criticality_constr_103,  memb_criticality_constraint_101 },
8780                 0, 0, /* No default value */
8781                 "criticality"
8782                 },
8783         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdate_IEs, value),
8784                 -1 /* Ambiguous tag (ANY?) */,
8785                 0,
8786                 &asn_DEF_value_104,
8787                 select_E2connectionUpdate_IEs_value_type,
8788                 { 0, &asn_PER_memb_value_constr_104,  memb_value_constraint_101 },
8789                 0, 0, /* No default value */
8790                 "value"
8791                 },
8792 };
8793 static const ber_tlv_tag_t asn_DEF_E2connectionUpdate_IEs_tags_101[] = {
8794         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8795 };
8796 static const asn_TYPE_tag2member_t asn_MAP_E2connectionUpdate_IEs_tag2el_101[] = {
8797     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8798     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8799 };
8800 asn_SEQUENCE_specifics_t asn_SPC_E2connectionUpdate_IEs_specs_101 = {
8801         sizeof(struct E2connectionUpdate_IEs),
8802         offsetof(struct E2connectionUpdate_IEs, _asn_ctx),
8803         asn_MAP_E2connectionUpdate_IEs_tag2el_101,
8804         2,      /* Count of tags in the map */
8805         0, 0, 0,        /* Optional elements (not needed) */
8806         -1,     /* First extension addition */
8807 };
8808 asn_TYPE_descriptor_t asn_DEF_E2connectionUpdate_IEs = {
8809         "E2connectionUpdate-IEs",
8810         "E2connectionUpdate-IEs",
8811         &asn_OP_SEQUENCE,
8812         asn_DEF_E2connectionUpdate_IEs_tags_101,
8813         sizeof(asn_DEF_E2connectionUpdate_IEs_tags_101)
8814                 /sizeof(asn_DEF_E2connectionUpdate_IEs_tags_101[0]), /* 1 */
8815         asn_DEF_E2connectionUpdate_IEs_tags_101,        /* Same as above */
8816         sizeof(asn_DEF_E2connectionUpdate_IEs_tags_101)
8817                 /sizeof(asn_DEF_E2connectionUpdate_IEs_tags_101[0]), /* 1 */
8818         { 0, 0, SEQUENCE_constraint },
8819         asn_MBR_E2connectionUpdate_IEs_101,
8820         3,      /* Elements count */
8821         &asn_SPC_E2connectionUpdate_IEs_specs_101       /* Additional specs */
8822 };
8823
8824 static asn_TYPE_member_t asn_MBR_value_108[] = {
8825         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateAck_IEs__value, choice.E2connectionUpdate_List),
8826                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8827                 0,
8828                 &asn_DEF_E2connectionUpdate_List,
8829                 0,
8830                 { 0, 0, 0 },
8831                 0, 0, /* No default value */
8832                 "E2connectionUpdate-List"
8833                 },
8834         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateAck_IEs__value, choice.E2connectionSetupFailed_List),
8835                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8836                 0,
8837                 &asn_DEF_E2connectionSetupFailed_List,
8838                 0,
8839                 { 0, 0, 0 },
8840                 0, 0, /* No default value */
8841                 "E2connectionSetupFailed-List"
8842                 },
8843 };
8844 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_108[] = {
8845     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* E2connectionUpdate-List */
8846     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* E2connectionSetupFailed-List */
8847 };
8848 static asn_CHOICE_specifics_t asn_SPC_value_specs_108 = {
8849         sizeof(struct E2connectionUpdateAck_IEs__value),
8850         offsetof(struct E2connectionUpdateAck_IEs__value, _asn_ctx),
8851         offsetof(struct E2connectionUpdateAck_IEs__value, present),
8852         sizeof(((struct E2connectionUpdateAck_IEs__value *)0)->present),
8853         asn_MAP_value_tag2el_108,
8854         2,      /* Count of tags in the map */
8855         0, 0,
8856         -1      /* Extensions start */
8857 };
8858 static /* Use -fall-defs-global to expose */
8859 asn_TYPE_descriptor_t asn_DEF_value_108 = {
8860         "value",
8861         "value",
8862         &asn_OP_OPEN_TYPE,
8863         0,      /* No effective tags (pointer) */
8864         0,      /* No effective tags (count) */
8865         0,      /* No tags (pointer) */
8866         0,      /* No tags (count) */
8867         { 0, 0, OPEN_TYPE_constraint },
8868         asn_MBR_value_108,
8869         2,      /* Elements count */
8870         &asn_SPC_value_specs_108        /* Additional specs */
8871 };
8872
8873 asn_TYPE_member_t asn_MBR_E2connectionUpdateAck_IEs_105[] = {
8874         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateAck_IEs, id),
8875                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
8876                 0,
8877                 &asn_DEF_ProtocolIE_ID,
8878                 0,
8879                 { 0, &asn_PER_memb_id_constr_106,  memb_id_constraint_105 },
8880                 0, 0, /* No default value */
8881                 "id"
8882                 },
8883         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateAck_IEs, criticality),
8884                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8885                 0,
8886                 &asn_DEF_Criticality,
8887                 select_E2connectionUpdateAck_IEs_criticality_type,
8888                 { 0, &asn_PER_memb_criticality_constr_107,  memb_criticality_constraint_105 },
8889                 0, 0, /* No default value */
8890                 "criticality"
8891                 },
8892         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateAck_IEs, value),
8893                 -1 /* Ambiguous tag (ANY?) */,
8894                 0,
8895                 &asn_DEF_value_108,
8896                 select_E2connectionUpdateAck_IEs_value_type,
8897                 { 0, &asn_PER_memb_value_constr_108,  memb_value_constraint_105 },
8898                 0, 0, /* No default value */
8899                 "value"
8900                 },
8901 };
8902 static const ber_tlv_tag_t asn_DEF_E2connectionUpdateAck_IEs_tags_105[] = {
8903         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
8904 };
8905 static const asn_TYPE_tag2member_t asn_MAP_E2connectionUpdateAck_IEs_tag2el_105[] = {
8906     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
8907     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
8908 };
8909 asn_SEQUENCE_specifics_t asn_SPC_E2connectionUpdateAck_IEs_specs_105 = {
8910         sizeof(struct E2connectionUpdateAck_IEs),
8911         offsetof(struct E2connectionUpdateAck_IEs, _asn_ctx),
8912         asn_MAP_E2connectionUpdateAck_IEs_tag2el_105,
8913         2,      /* Count of tags in the map */
8914         0, 0, 0,        /* Optional elements (not needed) */
8915         -1,     /* First extension addition */
8916 };
8917 asn_TYPE_descriptor_t asn_DEF_E2connectionUpdateAck_IEs = {
8918         "E2connectionUpdateAck-IEs",
8919         "E2connectionUpdateAck-IEs",
8920         &asn_OP_SEQUENCE,
8921         asn_DEF_E2connectionUpdateAck_IEs_tags_105,
8922         sizeof(asn_DEF_E2connectionUpdateAck_IEs_tags_105)
8923                 /sizeof(asn_DEF_E2connectionUpdateAck_IEs_tags_105[0]), /* 1 */
8924         asn_DEF_E2connectionUpdateAck_IEs_tags_105,     /* Same as above */
8925         sizeof(asn_DEF_E2connectionUpdateAck_IEs_tags_105)
8926                 /sizeof(asn_DEF_E2connectionUpdateAck_IEs_tags_105[0]), /* 1 */
8927         { 0, 0, SEQUENCE_constraint },
8928         asn_MBR_E2connectionUpdateAck_IEs_105,
8929         3,      /* Elements count */
8930         &asn_SPC_E2connectionUpdateAck_IEs_specs_105    /* Additional specs */
8931 };
8932
8933 static asn_TYPE_member_t asn_MBR_value_112[] = {
8934         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateFailure_IEs__value, choice.Cause),
8935                 -1 /* Ambiguous tag (CHOICE?) */,
8936                 0,
8937                 &asn_DEF_Cause,
8938                 0,
8939                 { 0, 0, 0 },
8940                 0, 0, /* No default value */
8941                 "Cause"
8942                 },
8943         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateFailure_IEs__value, choice.TimeToWait),
8944                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
8945                 0,
8946                 &asn_DEF_TimeToWait,
8947                 0,
8948                 { 0, 0, 0 },
8949                 0, 0, /* No default value */
8950                 "TimeToWait"
8951                 },
8952         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
8953                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
8954                 0,
8955                 &asn_DEF_CriticalityDiagnostics,
8956                 0,
8957                 { 0, 0, 0 },
8958                 0, 0, /* No default value */
8959                 "CriticalityDiagnostics"
8960                 },
8961 };
8962 static const unsigned asn_MAP_value_to_canonical_112[] = { 1, 2, 0 };
8963 static const unsigned asn_MAP_value_from_canonical_112[] = { 2, 0, 1 };
8964 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_112[] = {
8965     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
8966     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 }, /* CriticalityDiagnostics */
8967     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
8968     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
8969     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
8970     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
8971     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
8972 };
8973 static asn_CHOICE_specifics_t asn_SPC_value_specs_112 = {
8974         sizeof(struct E2connectionUpdateFailure_IEs__value),
8975         offsetof(struct E2connectionUpdateFailure_IEs__value, _asn_ctx),
8976         offsetof(struct E2connectionUpdateFailure_IEs__value, present),
8977         sizeof(((struct E2connectionUpdateFailure_IEs__value *)0)->present),
8978         asn_MAP_value_tag2el_112,
8979         7,      /* Count of tags in the map */
8980         asn_MAP_value_to_canonical_112,
8981         asn_MAP_value_from_canonical_112,
8982         -1      /* Extensions start */
8983 };
8984 static /* Use -fall-defs-global to expose */
8985 asn_TYPE_descriptor_t asn_DEF_value_112 = {
8986         "value",
8987         "value",
8988         &asn_OP_OPEN_TYPE,
8989         0,      /* No effective tags (pointer) */
8990         0,      /* No effective tags (count) */
8991         0,      /* No tags (pointer) */
8992         0,      /* No tags (count) */
8993         { 0, 0, OPEN_TYPE_constraint },
8994         asn_MBR_value_112,
8995         3,      /* Elements count */
8996         &asn_SPC_value_specs_112        /* Additional specs */
8997 };
8998
8999 asn_TYPE_member_t asn_MBR_E2connectionUpdateFailure_IEs_109[] = {
9000         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateFailure_IEs, id),
9001                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9002                 0,
9003                 &asn_DEF_ProtocolIE_ID,
9004                 0,
9005                 { 0, &asn_PER_memb_id_constr_110,  memb_id_constraint_109 },
9006                 0, 0, /* No default value */
9007                 "id"
9008                 },
9009         { ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateFailure_IEs, criticality),
9010                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9011                 0,
9012                 &asn_DEF_Criticality,
9013                 select_E2connectionUpdateFailure_IEs_criticality_type,
9014                 { 0, &asn_PER_memb_criticality_constr_111,  memb_criticality_constraint_109 },
9015                 0, 0, /* No default value */
9016                 "criticality"
9017                 },
9018         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2connectionUpdateFailure_IEs, value),
9019                 -1 /* Ambiguous tag (ANY?) */,
9020                 0,
9021                 &asn_DEF_value_112,
9022                 select_E2connectionUpdateFailure_IEs_value_type,
9023                 { 0, &asn_PER_memb_value_constr_112,  memb_value_constraint_109 },
9024                 0, 0, /* No default value */
9025                 "value"
9026                 },
9027 };
9028 static const ber_tlv_tag_t asn_DEF_E2connectionUpdateFailure_IEs_tags_109[] = {
9029         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9030 };
9031 static const asn_TYPE_tag2member_t asn_MAP_E2connectionUpdateFailure_IEs_tag2el_109[] = {
9032     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9033     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9034 };
9035 asn_SEQUENCE_specifics_t asn_SPC_E2connectionUpdateFailure_IEs_specs_109 = {
9036         sizeof(struct E2connectionUpdateFailure_IEs),
9037         offsetof(struct E2connectionUpdateFailure_IEs, _asn_ctx),
9038         asn_MAP_E2connectionUpdateFailure_IEs_tag2el_109,
9039         2,      /* Count of tags in the map */
9040         0, 0, 0,        /* Optional elements (not needed) */
9041         -1,     /* First extension addition */
9042 };
9043 asn_TYPE_descriptor_t asn_DEF_E2connectionUpdateFailure_IEs = {
9044         "E2connectionUpdateFailure-IEs",
9045         "E2connectionUpdateFailure-IEs",
9046         &asn_OP_SEQUENCE,
9047         asn_DEF_E2connectionUpdateFailure_IEs_tags_109,
9048         sizeof(asn_DEF_E2connectionUpdateFailure_IEs_tags_109)
9049                 /sizeof(asn_DEF_E2connectionUpdateFailure_IEs_tags_109[0]), /* 1 */
9050         asn_DEF_E2connectionUpdateFailure_IEs_tags_109, /* Same as above */
9051         sizeof(asn_DEF_E2connectionUpdateFailure_IEs_tags_109)
9052                 /sizeof(asn_DEF_E2connectionUpdateFailure_IEs_tags_109[0]), /* 1 */
9053         { 0, 0, SEQUENCE_constraint },
9054         asn_MBR_E2connectionUpdateFailure_IEs_109,
9055         3,      /* Elements count */
9056         &asn_SPC_E2connectionUpdateFailure_IEs_specs_109        /* Additional specs */
9057 };
9058
9059 static asn_TYPE_member_t asn_MBR_value_116[] = {
9060         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdate_IEs__value, choice.E2nodeComponentConfigUpdate_List),
9061                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9062                 0,
9063                 &asn_DEF_E2nodeComponentConfigUpdate_List,
9064                 0,
9065                 { 0, 0, 0 },
9066                 0, 0, /* No default value */
9067                 "E2nodeComponentConfigUpdate-List"
9068                 },
9069 };
9070 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_116[] = {
9071     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2nodeComponentConfigUpdate-List */
9072 };
9073 static asn_CHOICE_specifics_t asn_SPC_value_specs_116 = {
9074         sizeof(struct E2nodeConfigurationUpdate_IEs__value),
9075         offsetof(struct E2nodeConfigurationUpdate_IEs__value, _asn_ctx),
9076         offsetof(struct E2nodeConfigurationUpdate_IEs__value, present),
9077         sizeof(((struct E2nodeConfigurationUpdate_IEs__value *)0)->present),
9078         asn_MAP_value_tag2el_116,
9079         1,      /* Count of tags in the map */
9080         0, 0,
9081         -1      /* Extensions start */
9082 };
9083 static /* Use -fall-defs-global to expose */
9084 asn_TYPE_descriptor_t asn_DEF_value_116 = {
9085         "value",
9086         "value",
9087         &asn_OP_OPEN_TYPE,
9088         0,      /* No effective tags (pointer) */
9089         0,      /* No effective tags (count) */
9090         0,      /* No tags (pointer) */
9091         0,      /* No tags (count) */
9092         { 0, 0, OPEN_TYPE_constraint },
9093         asn_MBR_value_116,
9094         1,      /* Elements count */
9095         &asn_SPC_value_specs_116        /* Additional specs */
9096 };
9097
9098 asn_TYPE_member_t asn_MBR_E2nodeConfigurationUpdate_IEs_113[] = {
9099         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdate_IEs, id),
9100                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9101                 0,
9102                 &asn_DEF_ProtocolIE_ID,
9103                 0,
9104                 { 0, &asn_PER_memb_id_constr_114,  memb_id_constraint_113 },
9105                 0, 0, /* No default value */
9106                 "id"
9107                 },
9108         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdate_IEs, criticality),
9109                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9110                 0,
9111                 &asn_DEF_Criticality,
9112                 select_E2nodeConfigurationUpdate_IEs_criticality_type,
9113                 { 0, &asn_PER_memb_criticality_constr_115,  memb_criticality_constraint_113 },
9114                 0, 0, /* No default value */
9115                 "criticality"
9116                 },
9117         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdate_IEs, value),
9118                 -1 /* Ambiguous tag (ANY?) */,
9119                 0,
9120                 &asn_DEF_value_116,
9121                 select_E2nodeConfigurationUpdate_IEs_value_type,
9122                 { 0, &asn_PER_memb_value_constr_116,  memb_value_constraint_113 },
9123                 0, 0, /* No default value */
9124                 "value"
9125                 },
9126 };
9127 static const ber_tlv_tag_t asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113[] = {
9128         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9129 };
9130 static const asn_TYPE_tag2member_t asn_MAP_E2nodeConfigurationUpdate_IEs_tag2el_113[] = {
9131     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9132     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9133 };
9134 asn_SEQUENCE_specifics_t asn_SPC_E2nodeConfigurationUpdate_IEs_specs_113 = {
9135         sizeof(struct E2nodeConfigurationUpdate_IEs),
9136         offsetof(struct E2nodeConfigurationUpdate_IEs, _asn_ctx),
9137         asn_MAP_E2nodeConfigurationUpdate_IEs_tag2el_113,
9138         2,      /* Count of tags in the map */
9139         0, 0, 0,        /* Optional elements (not needed) */
9140         -1,     /* First extension addition */
9141 };
9142 asn_TYPE_descriptor_t asn_DEF_E2nodeConfigurationUpdate_IEs = {
9143         "E2nodeConfigurationUpdate-IEs",
9144         "E2nodeConfigurationUpdate-IEs",
9145         &asn_OP_SEQUENCE,
9146         asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113,
9147         sizeof(asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113)
9148                 /sizeof(asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113[0]), /* 1 */
9149         asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113, /* Same as above */
9150         sizeof(asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113)
9151                 /sizeof(asn_DEF_E2nodeConfigurationUpdate_IEs_tags_113[0]), /* 1 */
9152         { 0, 0, SEQUENCE_constraint },
9153         asn_MBR_E2nodeConfigurationUpdate_IEs_113,
9154         3,      /* Elements count */
9155         &asn_SPC_E2nodeConfigurationUpdate_IEs_specs_113        /* Additional specs */
9156 };
9157
9158 static asn_TYPE_member_t asn_MBR_value_120[] = {
9159         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs__value, choice.E2nodeComponentConfigUpdateAck_List),
9160                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9161                 0,
9162                 &asn_DEF_E2nodeComponentConfigUpdateAck_List,
9163                 0,
9164                 { 0, 0, 0 },
9165                 0, 0, /* No default value */
9166                 "E2nodeComponentConfigUpdateAck-List"
9167                 },
9168 };
9169 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_120[] = {
9170     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* E2nodeComponentConfigUpdateAck-List */
9171 };
9172 static asn_CHOICE_specifics_t asn_SPC_value_specs_120 = {
9173         sizeof(struct E2nodeConfigurationUpdateAcknowledge_IEs__value),
9174         offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs__value, _asn_ctx),
9175         offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs__value, present),
9176         sizeof(((struct E2nodeConfigurationUpdateAcknowledge_IEs__value *)0)->present),
9177         asn_MAP_value_tag2el_120,
9178         1,      /* Count of tags in the map */
9179         0, 0,
9180         -1      /* Extensions start */
9181 };
9182 static /* Use -fall-defs-global to expose */
9183 asn_TYPE_descriptor_t asn_DEF_value_120 = {
9184         "value",
9185         "value",
9186         &asn_OP_OPEN_TYPE,
9187         0,      /* No effective tags (pointer) */
9188         0,      /* No effective tags (count) */
9189         0,      /* No tags (pointer) */
9190         0,      /* No tags (count) */
9191         { 0, 0, OPEN_TYPE_constraint },
9192         asn_MBR_value_120,
9193         1,      /* Elements count */
9194         &asn_SPC_value_specs_120        /* Additional specs */
9195 };
9196
9197 asn_TYPE_member_t asn_MBR_E2nodeConfigurationUpdateAcknowledge_IEs_117[] = {
9198         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs, id),
9199                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9200                 0,
9201                 &asn_DEF_ProtocolIE_ID,
9202                 0,
9203                 { 0, &asn_PER_memb_id_constr_118,  memb_id_constraint_117 },
9204                 0, 0, /* No default value */
9205                 "id"
9206                 },
9207         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs, criticality),
9208                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9209                 0,
9210                 &asn_DEF_Criticality,
9211                 select_E2nodeConfigurationUpdateAcknowledge_IEs_criticality_type,
9212                 { 0, &asn_PER_memb_criticality_constr_119,  memb_criticality_constraint_117 },
9213                 0, 0, /* No default value */
9214                 "criticality"
9215                 },
9216         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs, value),
9217                 -1 /* Ambiguous tag (ANY?) */,
9218                 0,
9219                 &asn_DEF_value_120,
9220                 select_E2nodeConfigurationUpdateAcknowledge_IEs_value_type,
9221                 { 0, &asn_PER_memb_value_constr_120,  memb_value_constraint_117 },
9222                 0, 0, /* No default value */
9223                 "value"
9224                 },
9225 };
9226 static const ber_tlv_tag_t asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117[] = {
9227         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9228 };
9229 static const asn_TYPE_tag2member_t asn_MAP_E2nodeConfigurationUpdateAcknowledge_IEs_tag2el_117[] = {
9230     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9231     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9232 };
9233 asn_SEQUENCE_specifics_t asn_SPC_E2nodeConfigurationUpdateAcknowledge_IEs_specs_117 = {
9234         sizeof(struct E2nodeConfigurationUpdateAcknowledge_IEs),
9235         offsetof(struct E2nodeConfigurationUpdateAcknowledge_IEs, _asn_ctx),
9236         asn_MAP_E2nodeConfigurationUpdateAcknowledge_IEs_tag2el_117,
9237         2,      /* Count of tags in the map */
9238         0, 0, 0,        /* Optional elements (not needed) */
9239         -1,     /* First extension addition */
9240 };
9241 asn_TYPE_descriptor_t asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs = {
9242         "E2nodeConfigurationUpdateAcknowledge-IEs",
9243         "E2nodeConfigurationUpdateAcknowledge-IEs",
9244         &asn_OP_SEQUENCE,
9245         asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117,
9246         sizeof(asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117)
9247                 /sizeof(asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117[0]), /* 1 */
9248         asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117,      /* Same as above */
9249         sizeof(asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117)
9250                 /sizeof(asn_DEF_E2nodeConfigurationUpdateAcknowledge_IEs_tags_117[0]), /* 1 */
9251         { 0, 0, SEQUENCE_constraint },
9252         asn_MBR_E2nodeConfigurationUpdateAcknowledge_IEs_117,
9253         3,      /* Elements count */
9254         &asn_SPC_E2nodeConfigurationUpdateAcknowledge_IEs_specs_117     /* Additional specs */
9255 };
9256
9257 static asn_TYPE_member_t asn_MBR_value_124[] = {
9258         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateFailure_IEs__value, choice.Cause),
9259                 -1 /* Ambiguous tag (CHOICE?) */,
9260                 0,
9261                 &asn_DEF_Cause,
9262                 0,
9263                 { 0, 0, 0 },
9264                 0, 0, /* No default value */
9265                 "Cause"
9266                 },
9267         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateFailure_IEs__value, choice.TimeToWait),
9268                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9269                 0,
9270                 &asn_DEF_TimeToWait,
9271                 0,
9272                 { 0, 0, 0 },
9273                 0, 0, /* No default value */
9274                 "TimeToWait"
9275                 },
9276         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
9277                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9278                 0,
9279                 &asn_DEF_CriticalityDiagnostics,
9280                 0,
9281                 { 0, 0, 0 },
9282                 0, 0, /* No default value */
9283                 "CriticalityDiagnostics"
9284                 },
9285 };
9286 static const unsigned asn_MAP_value_to_canonical_124[] = { 1, 2, 0 };
9287 static const unsigned asn_MAP_value_from_canonical_124[] = { 2, 0, 1 };
9288 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_124[] = {
9289     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
9290     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 }, /* CriticalityDiagnostics */
9291     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
9292     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
9293     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
9294     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
9295     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
9296 };
9297 static asn_CHOICE_specifics_t asn_SPC_value_specs_124 = {
9298         sizeof(struct E2nodeConfigurationUpdateFailure_IEs__value),
9299         offsetof(struct E2nodeConfigurationUpdateFailure_IEs__value, _asn_ctx),
9300         offsetof(struct E2nodeConfigurationUpdateFailure_IEs__value, present),
9301         sizeof(((struct E2nodeConfigurationUpdateFailure_IEs__value *)0)->present),
9302         asn_MAP_value_tag2el_124,
9303         7,      /* Count of tags in the map */
9304         asn_MAP_value_to_canonical_124,
9305         asn_MAP_value_from_canonical_124,
9306         -1      /* Extensions start */
9307 };
9308 static /* Use -fall-defs-global to expose */
9309 asn_TYPE_descriptor_t asn_DEF_value_124 = {
9310         "value",
9311         "value",
9312         &asn_OP_OPEN_TYPE,
9313         0,      /* No effective tags (pointer) */
9314         0,      /* No effective tags (count) */
9315         0,      /* No tags (pointer) */
9316         0,      /* No tags (count) */
9317         { 0, 0, OPEN_TYPE_constraint },
9318         asn_MBR_value_124,
9319         3,      /* Elements count */
9320         &asn_SPC_value_specs_124        /* Additional specs */
9321 };
9322
9323 asn_TYPE_member_t asn_MBR_E2nodeConfigurationUpdateFailure_IEs_121[] = {
9324         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateFailure_IEs, id),
9325                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9326                 0,
9327                 &asn_DEF_ProtocolIE_ID,
9328                 0,
9329                 { 0, &asn_PER_memb_id_constr_122,  memb_id_constraint_121 },
9330                 0, 0, /* No default value */
9331                 "id"
9332                 },
9333         { ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateFailure_IEs, criticality),
9334                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9335                 0,
9336                 &asn_DEF_Criticality,
9337                 select_E2nodeConfigurationUpdateFailure_IEs_criticality_type,
9338                 { 0, &asn_PER_memb_criticality_constr_123,  memb_criticality_constraint_121 },
9339                 0, 0, /* No default value */
9340                 "criticality"
9341                 },
9342         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2nodeConfigurationUpdateFailure_IEs, value),
9343                 -1 /* Ambiguous tag (ANY?) */,
9344                 0,
9345                 &asn_DEF_value_124,
9346                 select_E2nodeConfigurationUpdateFailure_IEs_value_type,
9347                 { 0, &asn_PER_memb_value_constr_124,  memb_value_constraint_121 },
9348                 0, 0, /* No default value */
9349                 "value"
9350                 },
9351 };
9352 static const ber_tlv_tag_t asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121[] = {
9353         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9354 };
9355 static const asn_TYPE_tag2member_t asn_MAP_E2nodeConfigurationUpdateFailure_IEs_tag2el_121[] = {
9356     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9357     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9358 };
9359 asn_SEQUENCE_specifics_t asn_SPC_E2nodeConfigurationUpdateFailure_IEs_specs_121 = {
9360         sizeof(struct E2nodeConfigurationUpdateFailure_IEs),
9361         offsetof(struct E2nodeConfigurationUpdateFailure_IEs, _asn_ctx),
9362         asn_MAP_E2nodeConfigurationUpdateFailure_IEs_tag2el_121,
9363         2,      /* Count of tags in the map */
9364         0, 0, 0,        /* Optional elements (not needed) */
9365         -1,     /* First extension addition */
9366 };
9367 asn_TYPE_descriptor_t asn_DEF_E2nodeConfigurationUpdateFailure_IEs = {
9368         "E2nodeConfigurationUpdateFailure-IEs",
9369         "E2nodeConfigurationUpdateFailure-IEs",
9370         &asn_OP_SEQUENCE,
9371         asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121,
9372         sizeof(asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121)
9373                 /sizeof(asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121[0]), /* 1 */
9374         asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121,  /* Same as above */
9375         sizeof(asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121)
9376                 /sizeof(asn_DEF_E2nodeConfigurationUpdateFailure_IEs_tags_121[0]), /* 1 */
9377         { 0, 0, SEQUENCE_constraint },
9378         asn_MBR_E2nodeConfigurationUpdateFailure_IEs_121,
9379         3,      /* Elements count */
9380         &asn_SPC_E2nodeConfigurationUpdateFailure_IEs_specs_121 /* Additional specs */
9381 };
9382
9383 static asn_TYPE_member_t asn_MBR_value_128[] = {
9384         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs__value, choice.Cause),
9385                 -1 /* Ambiguous tag (CHOICE?) */,
9386                 0,
9387                 &asn_DEF_Cause,
9388                 0,
9389                 { 0, 0, 0 },
9390                 0, 0, /* No default value */
9391                 "Cause"
9392                 },
9393 };
9394 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_128[] = {
9395     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
9396     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
9397     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
9398     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
9399     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
9400 };
9401 static asn_CHOICE_specifics_t asn_SPC_value_specs_128 = {
9402         sizeof(struct ResetRequestIEs__value),
9403         offsetof(struct ResetRequestIEs__value, _asn_ctx),
9404         offsetof(struct ResetRequestIEs__value, present),
9405         sizeof(((struct ResetRequestIEs__value *)0)->present),
9406         asn_MAP_value_tag2el_128,
9407         5,      /* Count of tags in the map */
9408         0, 0,
9409         -1      /* Extensions start */
9410 };
9411 static /* Use -fall-defs-global to expose */
9412 asn_TYPE_descriptor_t asn_DEF_value_128 = {
9413         "value",
9414         "value",
9415         &asn_OP_OPEN_TYPE,
9416         0,      /* No effective tags (pointer) */
9417         0,      /* No effective tags (count) */
9418         0,      /* No tags (pointer) */
9419         0,      /* No tags (count) */
9420         { 0, 0, OPEN_TYPE_constraint },
9421         asn_MBR_value_128,
9422         1,      /* Elements count */
9423         &asn_SPC_value_specs_128        /* Additional specs */
9424 };
9425
9426 asn_TYPE_member_t asn_MBR_ResetRequestIEs_125[] = {
9427         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, id),
9428                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9429                 0,
9430                 &asn_DEF_ProtocolIE_ID,
9431                 0,
9432                 { 0, &asn_PER_memb_id_constr_126,  memb_id_constraint_125 },
9433                 0, 0, /* No default value */
9434                 "id"
9435                 },
9436         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, criticality),
9437                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9438                 0,
9439                 &asn_DEF_Criticality,
9440                 select_ResetRequestIEs_criticality_type,
9441                 { 0, &asn_PER_memb_criticality_constr_127,  memb_criticality_constraint_125 },
9442                 0, 0, /* No default value */
9443                 "criticality"
9444                 },
9445         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, value),
9446                 -1 /* Ambiguous tag (ANY?) */,
9447                 0,
9448                 &asn_DEF_value_128,
9449                 select_ResetRequestIEs_value_type,
9450                 { 0, &asn_PER_memb_value_constr_128,  memb_value_constraint_125 },
9451                 0, 0, /* No default value */
9452                 "value"
9453                 },
9454 };
9455 static const ber_tlv_tag_t asn_DEF_ResetRequestIEs_tags_125[] = {
9456         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9457 };
9458 static const asn_TYPE_tag2member_t asn_MAP_ResetRequestIEs_tag2el_125[] = {
9459     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9460     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9461 };
9462 asn_SEQUENCE_specifics_t asn_SPC_ResetRequestIEs_specs_125 = {
9463         sizeof(struct ResetRequestIEs),
9464         offsetof(struct ResetRequestIEs, _asn_ctx),
9465         asn_MAP_ResetRequestIEs_tag2el_125,
9466         2,      /* Count of tags in the map */
9467         0, 0, 0,        /* Optional elements (not needed) */
9468         -1,     /* First extension addition */
9469 };
9470 asn_TYPE_descriptor_t asn_DEF_ResetRequestIEs = {
9471         "ResetRequestIEs",
9472         "ResetRequestIEs",
9473         &asn_OP_SEQUENCE,
9474         asn_DEF_ResetRequestIEs_tags_125,
9475         sizeof(asn_DEF_ResetRequestIEs_tags_125)
9476                 /sizeof(asn_DEF_ResetRequestIEs_tags_125[0]), /* 1 */
9477         asn_DEF_ResetRequestIEs_tags_125,       /* Same as above */
9478         sizeof(asn_DEF_ResetRequestIEs_tags_125)
9479                 /sizeof(asn_DEF_ResetRequestIEs_tags_125[0]), /* 1 */
9480         { 0, 0, SEQUENCE_constraint },
9481         asn_MBR_ResetRequestIEs_125,
9482         3,      /* Elements count */
9483         &asn_SPC_ResetRequestIEs_specs_125      /* Additional specs */
9484 };
9485
9486 static asn_TYPE_member_t asn_MBR_value_132[] = {
9487         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs__value, choice.CriticalityDiagnostics),
9488                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9489                 0,
9490                 &asn_DEF_CriticalityDiagnostics,
9491                 0,
9492                 { 0, 0, 0 },
9493                 0, 0, /* No default value */
9494                 "CriticalityDiagnostics"
9495                 },
9496 };
9497 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_132[] = {
9498     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* CriticalityDiagnostics */
9499 };
9500 static asn_CHOICE_specifics_t asn_SPC_value_specs_132 = {
9501         sizeof(struct ResetResponseIEs__value),
9502         offsetof(struct ResetResponseIEs__value, _asn_ctx),
9503         offsetof(struct ResetResponseIEs__value, present),
9504         sizeof(((struct ResetResponseIEs__value *)0)->present),
9505         asn_MAP_value_tag2el_132,
9506         1,      /* Count of tags in the map */
9507         0, 0,
9508         -1      /* Extensions start */
9509 };
9510 static /* Use -fall-defs-global to expose */
9511 asn_TYPE_descriptor_t asn_DEF_value_132 = {
9512         "value",
9513         "value",
9514         &asn_OP_OPEN_TYPE,
9515         0,      /* No effective tags (pointer) */
9516         0,      /* No effective tags (count) */
9517         0,      /* No tags (pointer) */
9518         0,      /* No tags (count) */
9519         { 0, 0, OPEN_TYPE_constraint },
9520         asn_MBR_value_132,
9521         1,      /* Elements count */
9522         &asn_SPC_value_specs_132        /* Additional specs */
9523 };
9524
9525 asn_TYPE_member_t asn_MBR_ResetResponseIEs_129[] = {
9526         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, id),
9527                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9528                 0,
9529                 &asn_DEF_ProtocolIE_ID,
9530                 0,
9531                 { 0, &asn_PER_memb_id_constr_130,  memb_id_constraint_129 },
9532                 0, 0, /* No default value */
9533                 "id"
9534                 },
9535         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, criticality),
9536                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9537                 0,
9538                 &asn_DEF_Criticality,
9539                 select_ResetResponseIEs_criticality_type,
9540                 { 0, &asn_PER_memb_criticality_constr_131,  memb_criticality_constraint_129 },
9541                 0, 0, /* No default value */
9542                 "criticality"
9543                 },
9544         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, value),
9545                 -1 /* Ambiguous tag (ANY?) */,
9546                 0,
9547                 &asn_DEF_value_132,
9548                 select_ResetResponseIEs_value_type,
9549                 { 0, &asn_PER_memb_value_constr_132,  memb_value_constraint_129 },
9550                 0, 0, /* No default value */
9551                 "value"
9552                 },
9553 };
9554 static const ber_tlv_tag_t asn_DEF_ResetResponseIEs_tags_129[] = {
9555         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9556 };
9557 static const asn_TYPE_tag2member_t asn_MAP_ResetResponseIEs_tag2el_129[] = {
9558     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9559     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9560 };
9561 asn_SEQUENCE_specifics_t asn_SPC_ResetResponseIEs_specs_129 = {
9562         sizeof(struct ResetResponseIEs),
9563         offsetof(struct ResetResponseIEs, _asn_ctx),
9564         asn_MAP_ResetResponseIEs_tag2el_129,
9565         2,      /* Count of tags in the map */
9566         0, 0, 0,        /* Optional elements (not needed) */
9567         -1,     /* First extension addition */
9568 };
9569 asn_TYPE_descriptor_t asn_DEF_ResetResponseIEs = {
9570         "ResetResponseIEs",
9571         "ResetResponseIEs",
9572         &asn_OP_SEQUENCE,
9573         asn_DEF_ResetResponseIEs_tags_129,
9574         sizeof(asn_DEF_ResetResponseIEs_tags_129)
9575                 /sizeof(asn_DEF_ResetResponseIEs_tags_129[0]), /* 1 */
9576         asn_DEF_ResetResponseIEs_tags_129,      /* Same as above */
9577         sizeof(asn_DEF_ResetResponseIEs_tags_129)
9578                 /sizeof(asn_DEF_ResetResponseIEs_tags_129[0]), /* 1 */
9579         { 0, 0, SEQUENCE_constraint },
9580         asn_MBR_ResetResponseIEs_129,
9581         3,      /* Elements count */
9582         &asn_SPC_ResetResponseIEs_specs_129     /* Additional specs */
9583 };
9584
9585 static asn_TYPE_member_t asn_MBR_value_136[] = {
9586         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctions_List),
9587                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9588                 0,
9589                 &asn_DEF_RANfunctions_List,
9590                 0,
9591                 { 0, 0, 0 },
9592                 0, 0, /* No default value */
9593                 "RANfunctions-List"
9594                 },
9595         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctionsID_List),
9596                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9597                 0,
9598                 &asn_DEF_RANfunctionsID_List,
9599                 0,
9600                 { 0, 0, 0 },
9601                 0, 0, /* No default value */
9602                 "RANfunctionsID-List"
9603                 },
9604 };
9605 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_136[] = {
9606     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctions-List */
9607     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsID-List */
9608 };
9609 static asn_CHOICE_specifics_t asn_SPC_value_specs_136 = {
9610         sizeof(struct RICserviceUpdate_IEs__value),
9611         offsetof(struct RICserviceUpdate_IEs__value, _asn_ctx),
9612         offsetof(struct RICserviceUpdate_IEs__value, present),
9613         sizeof(((struct RICserviceUpdate_IEs__value *)0)->present),
9614         asn_MAP_value_tag2el_136,
9615         2,      /* Count of tags in the map */
9616         0, 0,
9617         -1      /* Extensions start */
9618 };
9619 static /* Use -fall-defs-global to expose */
9620 asn_TYPE_descriptor_t asn_DEF_value_136 = {
9621         "value",
9622         "value",
9623         &asn_OP_OPEN_TYPE,
9624         0,      /* No effective tags (pointer) */
9625         0,      /* No effective tags (count) */
9626         0,      /* No tags (pointer) */
9627         0,      /* No tags (count) */
9628         { 0, 0, OPEN_TYPE_constraint },
9629         asn_MBR_value_136,
9630         2,      /* Elements count */
9631         &asn_SPC_value_specs_136        /* Additional specs */
9632 };
9633
9634 asn_TYPE_member_t asn_MBR_RICserviceUpdate_IEs_133[] = {
9635         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, id),
9636                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9637                 0,
9638                 &asn_DEF_ProtocolIE_ID,
9639                 0,
9640                 { 0, &asn_PER_memb_id_constr_134,  memb_id_constraint_133 },
9641                 0, 0, /* No default value */
9642                 "id"
9643                 },
9644         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, criticality),
9645                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9646                 0,
9647                 &asn_DEF_Criticality,
9648                 select_RICserviceUpdate_IEs_criticality_type,
9649                 { 0, &asn_PER_memb_criticality_constr_135,  memb_criticality_constraint_133 },
9650                 0, 0, /* No default value */
9651                 "criticality"
9652                 },
9653         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, value),
9654                 -1 /* Ambiguous tag (ANY?) */,
9655                 0,
9656                 &asn_DEF_value_136,
9657                 select_RICserviceUpdate_IEs_value_type,
9658                 { 0, &asn_PER_memb_value_constr_136,  memb_value_constraint_133 },
9659                 0, 0, /* No default value */
9660                 "value"
9661                 },
9662 };
9663 static const ber_tlv_tag_t asn_DEF_RICserviceUpdate_IEs_tags_133[] = {
9664         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9665 };
9666 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdate_IEs_tag2el_133[] = {
9667     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9668     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9669 };
9670 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdate_IEs_specs_133 = {
9671         sizeof(struct RICserviceUpdate_IEs),
9672         offsetof(struct RICserviceUpdate_IEs, _asn_ctx),
9673         asn_MAP_RICserviceUpdate_IEs_tag2el_133,
9674         2,      /* Count of tags in the map */
9675         0, 0, 0,        /* Optional elements (not needed) */
9676         -1,     /* First extension addition */
9677 };
9678 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdate_IEs = {
9679         "RICserviceUpdate-IEs",
9680         "RICserviceUpdate-IEs",
9681         &asn_OP_SEQUENCE,
9682         asn_DEF_RICserviceUpdate_IEs_tags_133,
9683         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_133)
9684                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_133[0]), /* 1 */
9685         asn_DEF_RICserviceUpdate_IEs_tags_133,  /* Same as above */
9686         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_133)
9687                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_133[0]), /* 1 */
9688         { 0, 0, SEQUENCE_constraint },
9689         asn_MBR_RICserviceUpdate_IEs_133,
9690         3,      /* Elements count */
9691         &asn_SPC_RICserviceUpdate_IEs_specs_133 /* Additional specs */
9692 };
9693
9694 static asn_TYPE_member_t asn_MBR_value_140[] = {
9695         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsID_List),
9696                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9697                 0,
9698                 &asn_DEF_RANfunctionsID_List,
9699                 0,
9700                 { 0, 0, 0 },
9701                 0, 0, /* No default value */
9702                 "RANfunctionsID-List"
9703                 },
9704         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsIDcause_List),
9705                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9706                 0,
9707                 &asn_DEF_RANfunctionsIDcause_List,
9708                 0,
9709                 { 0, 0, 0 },
9710                 0, 0, /* No default value */
9711                 "RANfunctionsIDcause-List"
9712                 },
9713 };
9714 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_140[] = {
9715     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsID-List */
9716     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsIDcause-List */
9717 };
9718 static asn_CHOICE_specifics_t asn_SPC_value_specs_140 = {
9719         sizeof(struct RICserviceUpdateAcknowledge_IEs__value),
9720         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, _asn_ctx),
9721         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, present),
9722         sizeof(((struct RICserviceUpdateAcknowledge_IEs__value *)0)->present),
9723         asn_MAP_value_tag2el_140,
9724         2,      /* Count of tags in the map */
9725         0, 0,
9726         -1      /* Extensions start */
9727 };
9728 static /* Use -fall-defs-global to expose */
9729 asn_TYPE_descriptor_t asn_DEF_value_140 = {
9730         "value",
9731         "value",
9732         &asn_OP_OPEN_TYPE,
9733         0,      /* No effective tags (pointer) */
9734         0,      /* No effective tags (count) */
9735         0,      /* No tags (pointer) */
9736         0,      /* No tags (count) */
9737         { 0, 0, OPEN_TYPE_constraint },
9738         asn_MBR_value_140,
9739         2,      /* Elements count */
9740         &asn_SPC_value_specs_140        /* Additional specs */
9741 };
9742
9743 asn_TYPE_member_t asn_MBR_RICserviceUpdateAcknowledge_IEs_137[] = {
9744         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, id),
9745                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9746                 0,
9747                 &asn_DEF_ProtocolIE_ID,
9748                 0,
9749                 { 0, &asn_PER_memb_id_constr_138,  memb_id_constraint_137 },
9750                 0, 0, /* No default value */
9751                 "id"
9752                 },
9753         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, criticality),
9754                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9755                 0,
9756                 &asn_DEF_Criticality,
9757                 select_RICserviceUpdateAcknowledge_IEs_criticality_type,
9758                 { 0, &asn_PER_memb_criticality_constr_139,  memb_criticality_constraint_137 },
9759                 0, 0, /* No default value */
9760                 "criticality"
9761                 },
9762         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, value),
9763                 -1 /* Ambiguous tag (ANY?) */,
9764                 0,
9765                 &asn_DEF_value_140,
9766                 select_RICserviceUpdateAcknowledge_IEs_value_type,
9767                 { 0, &asn_PER_memb_value_constr_140,  memb_value_constraint_137 },
9768                 0, 0, /* No default value */
9769                 "value"
9770                 },
9771 };
9772 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137[] = {
9773         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9774 };
9775 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_137[] = {
9776     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9777     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9778 };
9779 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_137 = {
9780         sizeof(struct RICserviceUpdateAcknowledge_IEs),
9781         offsetof(struct RICserviceUpdateAcknowledge_IEs, _asn_ctx),
9782         asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_137,
9783         2,      /* Count of tags in the map */
9784         0, 0, 0,        /* Optional elements (not needed) */
9785         -1,     /* First extension addition */
9786 };
9787 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateAcknowledge_IEs = {
9788         "RICserviceUpdateAcknowledge-IEs",
9789         "RICserviceUpdateAcknowledge-IEs",
9790         &asn_OP_SEQUENCE,
9791         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137,
9792         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137)
9793                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137[0]), /* 1 */
9794         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137,       /* Same as above */
9795         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137)
9796                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_137[0]), /* 1 */
9797         { 0, 0, SEQUENCE_constraint },
9798         asn_MBR_RICserviceUpdateAcknowledge_IEs_137,
9799         3,      /* Elements count */
9800         &asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_137      /* Additional specs */
9801 };
9802
9803 static asn_TYPE_member_t asn_MBR_value_144[] = {
9804         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.RANfunctionsIDcause_List),
9805                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9806                 0,
9807                 &asn_DEF_RANfunctionsIDcause_List,
9808                 0,
9809                 { 0, 0, 0 },
9810                 0, 0, /* No default value */
9811                 "RANfunctionsIDcause-List"
9812                 },
9813         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.TimeToWait),
9814                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9815                 0,
9816                 &asn_DEF_TimeToWait,
9817                 0,
9818                 { 0, 0, 0 },
9819                 0, 0, /* No default value */
9820                 "TimeToWait"
9821                 },
9822         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
9823                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9824                 0,
9825                 &asn_DEF_CriticalityDiagnostics,
9826                 0,
9827                 { 0, 0, 0 },
9828                 0, 0, /* No default value */
9829                 "CriticalityDiagnostics"
9830                 },
9831 };
9832 static const unsigned asn_MAP_value_to_canonical_144[] = { 1, 0, 2 };
9833 static const unsigned asn_MAP_value_from_canonical_144[] = { 1, 0, 2 };
9834 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_144[] = {
9835     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
9836     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsIDcause-List */
9837     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* CriticalityDiagnostics */
9838 };
9839 static asn_CHOICE_specifics_t asn_SPC_value_specs_144 = {
9840         sizeof(struct RICserviceUpdateFailure_IEs__value),
9841         offsetof(struct RICserviceUpdateFailure_IEs__value, _asn_ctx),
9842         offsetof(struct RICserviceUpdateFailure_IEs__value, present),
9843         sizeof(((struct RICserviceUpdateFailure_IEs__value *)0)->present),
9844         asn_MAP_value_tag2el_144,
9845         3,      /* Count of tags in the map */
9846         asn_MAP_value_to_canonical_144,
9847         asn_MAP_value_from_canonical_144,
9848         -1      /* Extensions start */
9849 };
9850 static /* Use -fall-defs-global to expose */
9851 asn_TYPE_descriptor_t asn_DEF_value_144 = {
9852         "value",
9853         "value",
9854         &asn_OP_OPEN_TYPE,
9855         0,      /* No effective tags (pointer) */
9856         0,      /* No effective tags (count) */
9857         0,      /* No tags (pointer) */
9858         0,      /* No tags (count) */
9859         { 0, 0, OPEN_TYPE_constraint },
9860         asn_MBR_value_144,
9861         3,      /* Elements count */
9862         &asn_SPC_value_specs_144        /* Additional specs */
9863 };
9864
9865 asn_TYPE_member_t asn_MBR_RICserviceUpdateFailure_IEs_141[] = {
9866         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, id),
9867                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9868                 0,
9869                 &asn_DEF_ProtocolIE_ID,
9870                 0,
9871                 { 0, &asn_PER_memb_id_constr_142,  memb_id_constraint_141 },
9872                 0, 0, /* No default value */
9873                 "id"
9874                 },
9875         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, criticality),
9876                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9877                 0,
9878                 &asn_DEF_Criticality,
9879                 select_RICserviceUpdateFailure_IEs_criticality_type,
9880                 { 0, &asn_PER_memb_criticality_constr_143,  memb_criticality_constraint_141 },
9881                 0, 0, /* No default value */
9882                 "criticality"
9883                 },
9884         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, value),
9885                 -1 /* Ambiguous tag (ANY?) */,
9886                 0,
9887                 &asn_DEF_value_144,
9888                 select_RICserviceUpdateFailure_IEs_value_type,
9889                 { 0, &asn_PER_memb_value_constr_144,  memb_value_constraint_141 },
9890                 0, 0, /* No default value */
9891                 "value"
9892                 },
9893 };
9894 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateFailure_IEs_tags_141[] = {
9895         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9896 };
9897 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateFailure_IEs_tag2el_141[] = {
9898     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9899     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9900 };
9901 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateFailure_IEs_specs_141 = {
9902         sizeof(struct RICserviceUpdateFailure_IEs),
9903         offsetof(struct RICserviceUpdateFailure_IEs, _asn_ctx),
9904         asn_MAP_RICserviceUpdateFailure_IEs_tag2el_141,
9905         2,      /* Count of tags in the map */
9906         0, 0, 0,        /* Optional elements (not needed) */
9907         -1,     /* First extension addition */
9908 };
9909 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateFailure_IEs = {
9910         "RICserviceUpdateFailure-IEs",
9911         "RICserviceUpdateFailure-IEs",
9912         &asn_OP_SEQUENCE,
9913         asn_DEF_RICserviceUpdateFailure_IEs_tags_141,
9914         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_141)
9915                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_141[0]), /* 1 */
9916         asn_DEF_RICserviceUpdateFailure_IEs_tags_141,   /* Same as above */
9917         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_141)
9918                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_141[0]), /* 1 */
9919         { 0, 0, SEQUENCE_constraint },
9920         asn_MBR_RICserviceUpdateFailure_IEs_141,
9921         3,      /* Elements count */
9922         &asn_SPC_RICserviceUpdateFailure_IEs_specs_141  /* Additional specs */
9923 };
9924
9925 static asn_TYPE_member_t asn_MBR_value_148[] = {
9926         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs__value, choice.RANfunctionsID_List),
9927                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
9928                 0,
9929                 &asn_DEF_RANfunctionsID_List,
9930                 0,
9931                 { 0, 0, 0 },
9932                 0, 0, /* No default value */
9933                 "RANfunctionsID-List"
9934                 },
9935 };
9936 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_148[] = {
9937     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionsID-List */
9938 };
9939 static asn_CHOICE_specifics_t asn_SPC_value_specs_148 = {
9940         sizeof(struct RICserviceQuery_IEs__value),
9941         offsetof(struct RICserviceQuery_IEs__value, _asn_ctx),
9942         offsetof(struct RICserviceQuery_IEs__value, present),
9943         sizeof(((struct RICserviceQuery_IEs__value *)0)->present),
9944         asn_MAP_value_tag2el_148,
9945         1,      /* Count of tags in the map */
9946         0, 0,
9947         -1      /* Extensions start */
9948 };
9949 static /* Use -fall-defs-global to expose */
9950 asn_TYPE_descriptor_t asn_DEF_value_148 = {
9951         "value",
9952         "value",
9953         &asn_OP_OPEN_TYPE,
9954         0,      /* No effective tags (pointer) */
9955         0,      /* No effective tags (count) */
9956         0,      /* No tags (pointer) */
9957         0,      /* No tags (count) */
9958         { 0, 0, OPEN_TYPE_constraint },
9959         asn_MBR_value_148,
9960         1,      /* Elements count */
9961         &asn_SPC_value_specs_148        /* Additional specs */
9962 };
9963
9964 asn_TYPE_member_t asn_MBR_RICserviceQuery_IEs_145[] = {
9965         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, id),
9966                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
9967                 0,
9968                 &asn_DEF_ProtocolIE_ID,
9969                 0,
9970                 { 0, &asn_PER_memb_id_constr_146,  memb_id_constraint_145 },
9971                 0, 0, /* No default value */
9972                 "id"
9973                 },
9974         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, criticality),
9975                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
9976                 0,
9977                 &asn_DEF_Criticality,
9978                 select_RICserviceQuery_IEs_criticality_type,
9979                 { 0, &asn_PER_memb_criticality_constr_147,  memb_criticality_constraint_145 },
9980                 0, 0, /* No default value */
9981                 "criticality"
9982                 },
9983         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, value),
9984                 -1 /* Ambiguous tag (ANY?) */,
9985                 0,
9986                 &asn_DEF_value_148,
9987                 select_RICserviceQuery_IEs_value_type,
9988                 { 0, &asn_PER_memb_value_constr_148,  memb_value_constraint_145 },
9989                 0, 0, /* No default value */
9990                 "value"
9991                 },
9992 };
9993 static const ber_tlv_tag_t asn_DEF_RICserviceQuery_IEs_tags_145[] = {
9994         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
9995 };
9996 static const asn_TYPE_tag2member_t asn_MAP_RICserviceQuery_IEs_tag2el_145[] = {
9997     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
9998     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
9999 };
10000 asn_SEQUENCE_specifics_t asn_SPC_RICserviceQuery_IEs_specs_145 = {
10001         sizeof(struct RICserviceQuery_IEs),
10002         offsetof(struct RICserviceQuery_IEs, _asn_ctx),
10003         asn_MAP_RICserviceQuery_IEs_tag2el_145,
10004         2,      /* Count of tags in the map */
10005         0, 0, 0,        /* Optional elements (not needed) */
10006         -1,     /* First extension addition */
10007 };
10008 asn_TYPE_descriptor_t asn_DEF_RICserviceQuery_IEs = {
10009         "RICserviceQuery-IEs",
10010         "RICserviceQuery-IEs",
10011         &asn_OP_SEQUENCE,
10012         asn_DEF_RICserviceQuery_IEs_tags_145,
10013         sizeof(asn_DEF_RICserviceQuery_IEs_tags_145)
10014                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_145[0]), /* 1 */
10015         asn_DEF_RICserviceQuery_IEs_tags_145,   /* Same as above */
10016         sizeof(asn_DEF_RICserviceQuery_IEs_tags_145)
10017                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_145[0]), /* 1 */
10018         { 0, 0, SEQUENCE_constraint },
10019         asn_MBR_RICserviceQuery_IEs_145,
10020         3,      /* Elements count */
10021         &asn_SPC_RICserviceQuery_IEs_specs_145  /* Additional specs */
10022 };
10023