asn1c_defs/E2N_ProtocolIE-Field.c

   1 /*
   2  * Generated by asn1c-0.9.29 n1 (http://lionet.info/asn1c)
   3  * From ASN.1 module "X2AP-Containers"
   4  *      found in "../../asn_defs/asn1/X2AP-minimized.asn"
   5  *      `asn1c -fcompound-names -fno-include-deps -findirect-choice -gen-PER -no-gen-OER`
   6  */
   7
   8 #include "E2N_ProtocolIE-Field.h"
   9
  10 static const long asn_VAL_4_E2N_id_RICaction_ToBeSetup_Item = 60011;
  11 static const long asn_VAL_4_E2N_ignore = 1;
  12 static const long asn_VAL_4_E2N_mandatory = 2;
  13 static const asn_ioc_cell_t asn_IOS_E2N_RICaction_ToBeSetup_ItemIEs_1_rows[] = {
  14         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_4_E2N_id_RICaction_ToBeSetup_Item },
  15         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_4_E2N_ignore },
  16         { "&Value", aioc__type, &asn_DEF_E2N_RICaction_ToBeSetup_Item },
  17         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_4_E2N_mandatory }
  18 };
  19 static const asn_ioc_set_t asn_IOS_E2N_RICaction_ToBeSetup_ItemIEs_1[] = {
  20         { 1, 4, asn_IOS_E2N_RICaction_ToBeSetup_ItemIEs_1_rows }
  21 };
  22 static const long asn_VAL_9_E2N_id_RICaction_Admitted_Item = 60013;
  23 static const long asn_VAL_9_E2N_ignore = 1;
  24 static const long asn_VAL_9_E2N_mandatory = 2;
  25 static const asn_ioc_cell_t asn_IOS_E2N_RICaction_Admitted_ItemIEs_1_rows[] = {
  26         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_9_E2N_id_RICaction_Admitted_Item },
  27         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_9_E2N_ignore },
  28         { "&Value", aioc__type, &asn_DEF_E2N_RICaction_Admitted_Item },
  29         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_9_E2N_mandatory }
  30 };
  31 static const asn_ioc_set_t asn_IOS_E2N_RICaction_Admitted_ItemIEs_1[] = {
  32         { 1, 4, asn_IOS_E2N_RICaction_Admitted_ItemIEs_1_rows }
  33 };
  34 static const long asn_VAL_10_E2N_id_RICaction_NotAdmitted_Item = 60015;
  35 static const long asn_VAL_10_E2N_ignore = 1;
  36 static const long asn_VAL_10_E2N_mandatory = 2;
  37 static const asn_ioc_cell_t asn_IOS_E2N_RICaction_NotAdmitted_ItemIEs_1_rows[] = {
  38         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_10_E2N_id_RICaction_NotAdmitted_Item },
  39         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_10_E2N_ignore },
  40         { "&Value", aioc__type, &asn_DEF_E2N_RICaction_NotAdmitted_Item },
  41         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_10_E2N_mandatory }
  42 };
  43 static const asn_ioc_set_t asn_IOS_E2N_RICaction_NotAdmitted_ItemIEs_1[] = {
  44         { 1, 4, asn_IOS_E2N_RICaction_NotAdmitted_ItemIEs_1_rows }
  45 };
  46 static const long asn_VAL_48_E2N_id_RANfunction_Item = 60001;
  47 static const long asn_VAL_48_E2N_ignore = 1;
  48 static const long asn_VAL_48_E2N_mandatory = 2;
  49 static const asn_ioc_cell_t asn_IOS_E2N_RANfunction_ItemIEs_1_rows[] = {
  50         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_48_E2N_id_RANfunction_Item },
  51         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_48_E2N_ignore },
  52         { "&Value", aioc__type, &asn_DEF_E2N_RANfunction_Item },
  53         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_48_E2N_mandatory }
  54 };
  55 static const asn_ioc_set_t asn_IOS_E2N_RANfunction_ItemIEs_1[] = {
  56         { 1, 4, asn_IOS_E2N_RANfunction_ItemIEs_1_rows }
  57 };
  58 static const long asn_VAL_49_E2N_id_RANfunctionID_Item = 60004;
  59 static const long asn_VAL_49_E2N_ignore = 1;
  60 static const long asn_VAL_49_E2N_mandatory = 2;
  61 static const asn_ioc_cell_t asn_IOS_E2N_RANfunctionID_ItemIEs_1_rows[] = {
  62         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_49_E2N_id_RANfunctionID_Item },
  63         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_49_E2N_ignore },
  64         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID_Item },
  65         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_49_E2N_mandatory }
  66 };
  67 static const asn_ioc_set_t asn_IOS_E2N_RANfunctionID_ItemIEs_1[] = {
  68         { 1, 4, asn_IOS_E2N_RANfunctionID_ItemIEs_1_rows }
  69 };
  70 static const long asn_VAL_52_E2N_id_RANfunctionIEcause_Item = 60005;
  71 static const long asn_VAL_52_E2N_ignore = 1;
  72 static const long asn_VAL_52_E2N_mandatory = 2;
  73 static const asn_ioc_cell_t asn_IOS_E2N_RANfunctionIDcause_ItemIEs_1_rows[] = {
  74         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_52_E2N_id_RANfunctionIEcause_Item },
  75         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_52_E2N_ignore },
  76         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionIDcause_Item },
  77         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_52_E2N_mandatory }
  78 };
  79 static const asn_ioc_set_t asn_IOS_E2N_RANfunctionIDcause_ItemIEs_1[] = {
  80         { 1, 4, asn_IOS_E2N_RANfunctionIDcause_ItemIEs_1_rows }
  81 };
  82 static const long asn_VAL_1_E2N_id_RICrequestID = 60030;
  83 static const long asn_VAL_1_E2N_reject = 0;
  84 static const long asn_VAL_1_E2N_mandatory = 2;
  85 static const long asn_VAL_2_E2N_id_RANfunctionID = 60003;
  86 static const long asn_VAL_2_E2N_reject = 0;
  87 static const long asn_VAL_2_E2N_mandatory = 2;
  88 static const long asn_VAL_3_E2N_id_RICsubscription = 60033;
  89 static const long asn_VAL_3_E2N_reject = 0;
  90 static const long asn_VAL_3_E2N_mandatory = 2;
  91 static const asn_ioc_cell_t asn_IOS_E2N_RICsubscriptionRequest_IEs_1_rows[] = {
  92         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_1_E2N_id_RICrequestID },
  93         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_1_E2N_reject },
  94         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
  95         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_1_E2N_mandatory },
  96         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_2_E2N_id_RANfunctionID },
  97         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_2_E2N_reject },
  98         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
  99         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_2_E2N_mandatory },
 100         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_3_E2N_id_RICsubscription },
 101         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_3_E2N_reject },
 102         { "&Value", aioc__type, &asn_DEF_E2N_RICsubscription },
 103         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_3_E2N_mandatory }
 104 };
 105 static const asn_ioc_set_t asn_IOS_E2N_RICsubscriptionRequest_IEs_1[] = {
 106         { 3, 4, asn_IOS_E2N_RICsubscriptionRequest_IEs_1_rows }
 107 };
 108 static const long asn_VAL_5_E2N_id_RICrequestID = 60030;
 109 static const long asn_VAL_5_E2N_reject = 0;
 110 static const long asn_VAL_5_E2N_mandatory = 2;
 111 static const long asn_VAL_6_E2N_id_RANfunctionID = 60003;
 112 static const long asn_VAL_6_E2N_reject = 0;
 113 static const long asn_VAL_6_E2N_mandatory = 2;
 114 static const long asn_VAL_7_E2N_id_RICactions_Admitted = 60012;
 115 static const long asn_VAL_7_E2N_reject = 0;
 116 static const long asn_VAL_7_E2N_mandatory = 2;
 117 static const long asn_VAL_8_E2N_id_RICactions_NotAdmitted = 60014;
 118 static const long asn_VAL_8_E2N_reject = 0;
 119 static const long asn_VAL_8_E2N_optional = 0;
 120 static const asn_ioc_cell_t asn_IOS_E2N_RICsubscriptionResponse_IEs_1_rows[] = {
 121         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_5_E2N_id_RICrequestID },
 122         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_5_E2N_reject },
 123         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 124         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_5_E2N_mandatory },
 125         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_6_E2N_id_RANfunctionID },
 126         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_6_E2N_reject },
 127         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 128         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_6_E2N_mandatory },
 129         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_7_E2N_id_RICactions_Admitted },
 130         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_7_E2N_reject },
 131         { "&Value", aioc__type, &asn_DEF_E2N_RICaction_Admitted_List },
 132         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_7_E2N_mandatory },
 133         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_8_E2N_id_RICactions_NotAdmitted },
 134         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_8_E2N_reject },
 135         { "&Value", aioc__type, &asn_DEF_E2N_RICaction_NotAdmitted_List },
 136         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_8_E2N_optional }
 137 };
 138 static const asn_ioc_set_t asn_IOS_E2N_RICsubscriptionResponse_IEs_1[] = {
 139         { 4, 4, asn_IOS_E2N_RICsubscriptionResponse_IEs_1_rows }
 140 };
 141 static const long asn_VAL_11_E2N_id_RICrequestID = 60030;
 142 static const long asn_VAL_11_E2N_reject = 0;
 143 static const long asn_VAL_11_E2N_mandatory = 2;
 144 static const long asn_VAL_12_E2N_id_RANfunctionID = 60003;
 145 static const long asn_VAL_12_E2N_reject = 0;
 146 static const long asn_VAL_12_E2N_mandatory = 2;
 147 static const long asn_VAL_13_E2N_id_RICactions_NotAdmitted = 60014;
 148 static const long asn_VAL_13_E2N_reject = 0;
 149 static const long asn_VAL_13_E2N_mandatory = 2;
 150 static const long asn_VAL_14_E2N_id_CriticalityDiagnostics = 17;
 151 static const long asn_VAL_14_E2N_ignore = 1;
 152 static const long asn_VAL_14_E2N_optional = 0;
 153 static const asn_ioc_cell_t asn_IOS_E2N_RICsubscriptionFailure_IEs_1_rows[] = {
 154         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_11_E2N_id_RICrequestID },
 155         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_11_E2N_reject },
 156         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 157         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_11_E2N_mandatory },
 158         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_12_E2N_id_RANfunctionID },
 159         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_12_E2N_reject },
 160         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 161         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_12_E2N_mandatory },
 162         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_13_E2N_id_RICactions_NotAdmitted },
 163         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_13_E2N_reject },
 164         { "&Value", aioc__type, &asn_DEF_E2N_RICaction_NotAdmitted_List },
 165         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_13_E2N_mandatory },
 166         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_14_E2N_id_CriticalityDiagnostics },
 167         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_14_E2N_ignore },
 168         { "&Value", aioc__type, &asn_DEF_E2N_CriticalityDiagnostics },
 169         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_14_E2N_optional }
 170 };
 171 static const asn_ioc_set_t asn_IOS_E2N_RICsubscriptionFailure_IEs_1[] = {
 172         { 4, 4, asn_IOS_E2N_RICsubscriptionFailure_IEs_1_rows }
 173 };
 174 static const long asn_VAL_15_E2N_id_RICrequestID = 60030;
 175 static const long asn_VAL_15_E2N_reject = 0;
 176 static const long asn_VAL_15_E2N_mandatory = 2;
 177 static const long asn_VAL_16_E2N_id_RANfunctionID = 60003;
 178 static const long asn_VAL_16_E2N_reject = 0;
 179 static const long asn_VAL_16_E2N_mandatory = 2;
 180 static const asn_ioc_cell_t asn_IOS_E2N_RICsubscriptionDeleteRequest_IEs_1_rows[] = {
 181         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_15_E2N_id_RICrequestID },
 182         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_15_E2N_reject },
 183         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 184         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_15_E2N_mandatory },
 185         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_16_E2N_id_RANfunctionID },
 186         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_16_E2N_reject },
 187         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 188         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_16_E2N_mandatory }
 189 };
 190 static const asn_ioc_set_t asn_IOS_E2N_RICsubscriptionDeleteRequest_IEs_1[] = {
 191         { 2, 4, asn_IOS_E2N_RICsubscriptionDeleteRequest_IEs_1_rows }
 192 };
 193 static const long asn_VAL_17_E2N_id_RICrequestID = 60030;
 194 static const long asn_VAL_17_E2N_reject = 0;
 195 static const long asn_VAL_17_E2N_mandatory = 2;
 196 static const long asn_VAL_18_E2N_id_RANfunctionID = 60003;
 197 static const long asn_VAL_18_E2N_reject = 0;
 198 static const long asn_VAL_18_E2N_mandatory = 2;
 199 static const asn_ioc_cell_t asn_IOS_E2N_RICsubscriptionDeleteResponse_IEs_1_rows[] = {
 200         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_17_E2N_id_RICrequestID },
 201         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_17_E2N_reject },
 202         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 203         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_17_E2N_mandatory },
 204         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_18_E2N_id_RANfunctionID },
 205         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_18_E2N_reject },
 206         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 207         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_18_E2N_mandatory }
 208 };
 209 static const asn_ioc_set_t asn_IOS_E2N_RICsubscriptionDeleteResponse_IEs_1[] = {
 210         { 2, 4, asn_IOS_E2N_RICsubscriptionDeleteResponse_IEs_1_rows }
 211 };
 212 static const long asn_VAL_19_E2N_id_RICrequestID = 60030;
 213 static const long asn_VAL_19_E2N_reject = 0;
 214 static const long asn_VAL_19_E2N_mandatory = 2;
 215 static const long asn_VAL_20_E2N_id_RANfunctionID = 60003;
 216 static const long asn_VAL_20_E2N_reject = 0;
 217 static const long asn_VAL_20_E2N_mandatory = 2;
 218 static const long asn_VAL_21_E2N_id_RICcause = 60020;
 219 static const long asn_VAL_21_E2N_ignore = 1;
 220 static const long asn_VAL_21_E2N_mandatory = 2;
 221 static const long asn_VAL_22_E2N_id_CriticalityDiagnostics = 17;
 222 static const long asn_VAL_22_E2N_ignore = 1;
 223 static const long asn_VAL_22_E2N_optional = 0;
 224 static const asn_ioc_cell_t asn_IOS_E2N_RICsubscriptionDeleteFailure_IEs_1_rows[] = {
 225         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_19_E2N_id_RICrequestID },
 226         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_19_E2N_reject },
 227         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 228         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_19_E2N_mandatory },
 229         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_20_E2N_id_RANfunctionID },
 230         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_20_E2N_reject },
 231         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 232         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_20_E2N_mandatory },
 233         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_21_E2N_id_RICcause },
 234         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_21_E2N_ignore },
 235         { "&Value", aioc__type, &asn_DEF_E2N_RICcause },
 236         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_21_E2N_mandatory },
 237         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_22_E2N_id_CriticalityDiagnostics },
 238         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_22_E2N_ignore },
 239         { "&Value", aioc__type, &asn_DEF_E2N_CriticalityDiagnostics },
 240         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_22_E2N_optional }
 241 };
 242 static const asn_ioc_set_t asn_IOS_E2N_RICsubscriptionDeleteFailure_IEs_1[] = {
 243         { 4, 4, asn_IOS_E2N_RICsubscriptionDeleteFailure_IEs_1_rows }
 244 };
 245 static const long asn_VAL_23_E2N_id_RICrequestID = 60030;
 246 static const long asn_VAL_23_E2N_reject = 0;
 247 static const long asn_VAL_23_E2N_mandatory = 2;
 248 static const long asn_VAL_24_E2N_id_RANfunctionID = 60003;
 249 static const long asn_VAL_24_E2N_reject = 0;
 250 static const long asn_VAL_24_E2N_mandatory = 2;
 251 static const long asn_VAL_25_E2N_id_RICactionID = 60017;
 252 static const long asn_VAL_25_E2N_reject = 0;
 253 static const long asn_VAL_25_E2N_mandatory = 2;
 254 static const long asn_VAL_26_E2N_id_RICindicationSN = 60028;
 255 static const long asn_VAL_26_E2N_reject = 0;
 256 static const long asn_VAL_26_E2N_mandatory = 2;
 257 static const long asn_VAL_27_E2N_id_RICindicationType = 60029;
 258 static const long asn_VAL_27_E2N_reject = 0;
 259 static const long asn_VAL_27_E2N_mandatory = 2;
 260 static const long asn_VAL_28_E2N_id_RICindicationHeader = 60026;
 261 static const long asn_VAL_28_E2N_reject = 0;
 262 static const long asn_VAL_28_E2N_mandatory = 2;
 263 static const long asn_VAL_29_E2N_id_RICindicationMessage = 60027;
 264 static const long asn_VAL_29_E2N_reject = 0;
 265 static const long asn_VAL_29_E2N_mandatory = 2;
 266 static const long asn_VAL_30_E2N_id_RICcallProcessID = 60019;
 267 static const long asn_VAL_30_E2N_reject = 0;
 268 static const long asn_VAL_30_E2N_optional = 0;
 269 static const asn_ioc_cell_t asn_IOS_E2N_RICindication_IEs_1_rows[] = {
 270         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_23_E2N_id_RICrequestID },
 271         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_23_E2N_reject },
 272         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 273         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_23_E2N_mandatory },
 274         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_24_E2N_id_RANfunctionID },
 275         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_24_E2N_reject },
 276         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 277         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_24_E2N_mandatory },
 278         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_25_E2N_id_RICactionID },
 279         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_25_E2N_reject },
 280         { "&Value", aioc__type, &asn_DEF_E2N_RICactionID },
 281         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_25_E2N_mandatory },
 282         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_26_E2N_id_RICindicationSN },
 283         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_26_E2N_reject },
 284         { "&Value", aioc__type, &asn_DEF_E2N_RICindicationSN },
 285         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_26_E2N_mandatory },
 286         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_27_E2N_id_RICindicationType },
 287         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_27_E2N_reject },
 288         { "&Value", aioc__type, &asn_DEF_E2N_RICindicationType },
 289         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_27_E2N_mandatory },
 290         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_28_E2N_id_RICindicationHeader },
 291         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_28_E2N_reject },
 292         { "&Value", aioc__type, &asn_DEF_E2N_RICindicationHeader },
 293         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_28_E2N_mandatory },
 294         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_29_E2N_id_RICindicationMessage },
 295         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_29_E2N_reject },
 296         { "&Value", aioc__type, &asn_DEF_E2N_RICindicationMessage },
 297         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_29_E2N_mandatory },
 298         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_30_E2N_id_RICcallProcessID },
 299         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_30_E2N_reject },
 300         { "&Value", aioc__type, &asn_DEF_E2N_RICcallProcessID },
 301         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_30_E2N_optional }
 302 };
 303 static const asn_ioc_set_t asn_IOS_E2N_RICindication_IEs_1[] = {
 304         { 8, 4, asn_IOS_E2N_RICindication_IEs_1_rows }
 305 };
 306 static const long asn_VAL_31_E2N_id_RICrequestID = 60030;
 307 static const long asn_VAL_31_E2N_reject = 0;
 308 static const long asn_VAL_31_E2N_mandatory = 2;
 309 static const long asn_VAL_32_E2N_id_RANfunctionID = 60003;
 310 static const long asn_VAL_32_E2N_reject = 0;
 311 static const long asn_VAL_32_E2N_mandatory = 2;
 312 static const long asn_VAL_33_E2N_id_RICcallProcessID = 60019;
 313 static const long asn_VAL_33_E2N_reject = 0;
 314 static const long asn_VAL_33_E2N_optional = 0;
 315 static const long asn_VAL_34_E2N_id_RICcontrolHeader = 60022;
 316 static const long asn_VAL_34_E2N_reject = 0;
 317 static const long asn_VAL_34_E2N_mandatory = 2;
 318 static const long asn_VAL_35_E2N_id_RICcontrolMessage = 60023;
 319 static const long asn_VAL_35_E2N_reject = 0;
 320 static const long asn_VAL_35_E2N_mandatory = 2;
 321 static const long asn_VAL_36_E2N_id_RICcontrolAckRequest = 60021;
 322 static const long asn_VAL_36_E2N_reject = 0;
 323 static const long asn_VAL_36_E2N_optional = 0;
 324 static const asn_ioc_cell_t asn_IOS_E2N_RICcontrolRequest_IEs_1_rows[] = {
 325         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_31_E2N_id_RICrequestID },
 326         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_31_E2N_reject },
 327         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 328         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_31_E2N_mandatory },
 329         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_32_E2N_id_RANfunctionID },
 330         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_32_E2N_reject },
 331         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 332         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_32_E2N_mandatory },
 333         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_33_E2N_id_RICcallProcessID },
 334         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_33_E2N_reject },
 335         { "&Value", aioc__type, &asn_DEF_E2N_RICcallProcessID },
 336         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_33_E2N_optional },
 337         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_34_E2N_id_RICcontrolHeader },
 338         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_34_E2N_reject },
 339         { "&Value", aioc__type, &asn_DEF_E2N_RICcontrolHeader },
 340         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_34_E2N_mandatory },
 341         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_35_E2N_id_RICcontrolMessage },
 342         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_35_E2N_reject },
 343         { "&Value", aioc__type, &asn_DEF_E2N_RICcontrolMessage },
 344         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_35_E2N_mandatory },
 345         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_36_E2N_id_RICcontrolAckRequest },
 346         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_36_E2N_reject },
 347         { "&Value", aioc__type, &asn_DEF_E2N_RICcontrolAckRequest },
 348         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_36_E2N_optional }
 349 };
 350 static const asn_ioc_set_t asn_IOS_E2N_RICcontrolRequest_IEs_1[] = {
 351         { 6, 4, asn_IOS_E2N_RICcontrolRequest_IEs_1_rows }
 352 };
 353 static const long asn_VAL_37_E2N_id_RICrequestID = 60030;
 354 static const long asn_VAL_37_E2N_reject = 0;
 355 static const long asn_VAL_37_E2N_mandatory = 2;
 356 static const long asn_VAL_38_E2N_id_RANfunctionID = 60003;
 357 static const long asn_VAL_38_E2N_reject = 0;
 358 static const long asn_VAL_38_E2N_mandatory = 2;
 359 static const long asn_VAL_39_E2N_id_RICcallProcessID = 60019;
 360 static const long asn_VAL_39_E2N_reject = 0;
 361 static const long asn_VAL_39_E2N_optional = 0;
 362 static const long asn_VAL_40_E2N_id_RICcontrolStatus = 60024;
 363 static const long asn_VAL_40_E2N_reject = 0;
 364 static const long asn_VAL_40_E2N_mandatory = 2;
 365 static const asn_ioc_cell_t asn_IOS_E2N_RICcontrolAcknowledge_IEs_1_rows[] = {
 366         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_37_E2N_id_RICrequestID },
 367         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_37_E2N_reject },
 368         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 369         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_37_E2N_mandatory },
 370         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_38_E2N_id_RANfunctionID },
 371         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_38_E2N_reject },
 372         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 373         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_38_E2N_mandatory },
 374         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_39_E2N_id_RICcallProcessID },
 375         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_39_E2N_reject },
 376         { "&Value", aioc__type, &asn_DEF_E2N_RICcallProcessID },
 377         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_39_E2N_optional },
 378         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_40_E2N_id_RICcontrolStatus },
 379         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_40_E2N_reject },
 380         { "&Value", aioc__type, &asn_DEF_E2N_RICcontrolStatus },
 381         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_40_E2N_mandatory }
 382 };
 383 static const asn_ioc_set_t asn_IOS_E2N_RICcontrolAcknowledge_IEs_1[] = {
 384         { 4, 4, asn_IOS_E2N_RICcontrolAcknowledge_IEs_1_rows }
 385 };
 386 static const long asn_VAL_41_E2N_id_RICrequestID = 60030;
 387 static const long asn_VAL_41_E2N_reject = 0;
 388 static const long asn_VAL_41_E2N_mandatory = 2;
 389 static const long asn_VAL_42_E2N_id_RANfunctionID = 60003;
 390 static const long asn_VAL_42_E2N_reject = 0;
 391 static const long asn_VAL_42_E2N_mandatory = 2;
 392 static const long asn_VAL_43_E2N_id_RICcallProcessID = 60019;
 393 static const long asn_VAL_43_E2N_reject = 0;
 394 static const long asn_VAL_43_E2N_optional = 0;
 395 static const long asn_VAL_44_E2N_id_RICcause = 60020;
 396 static const long asn_VAL_44_E2N_ignore = 1;
 397 static const long asn_VAL_44_E2N_mandatory = 2;
 398 static const asn_ioc_cell_t asn_IOS_E2N_RICcontrolFailure_IEs_1_rows[] = {
 399         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_41_E2N_id_RICrequestID },
 400         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_41_E2N_reject },
 401         { "&Value", aioc__type, &asn_DEF_E2N_RICrequestID },
 402         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_41_E2N_mandatory },
 403         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_42_E2N_id_RANfunctionID },
 404         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_42_E2N_reject },
 405         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionID },
 406         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_42_E2N_mandatory },
 407         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_43_E2N_id_RICcallProcessID },
 408         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_43_E2N_reject },
 409         { "&Value", aioc__type, &asn_DEF_E2N_RICcallProcessID },
 410         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_43_E2N_optional },
 411         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_44_E2N_id_RICcause },
 412         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_44_E2N_ignore },
 413         { "&Value", aioc__type, &asn_DEF_E2N_RICcause },
 414         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_44_E2N_mandatory }
 415 };
 416 static const asn_ioc_set_t asn_IOS_E2N_RICcontrolFailure_IEs_1[] = {
 417         { 4, 4, asn_IOS_E2N_RICcontrolFailure_IEs_1_rows }
 418 };
 419 static const long asn_VAL_45_E2N_id_RANfunctionsAdded = 60007;
 420 static const long asn_VAL_45_E2N_reject = 0;
 421 static const long asn_VAL_45_E2N_optional = 0;
 422 static const long asn_VAL_46_E2N_id_RANfunctionsModified = 60009;
 423 static const long asn_VAL_46_E2N_reject = 0;
 424 static const long asn_VAL_46_E2N_optional = 0;
 425 static const long asn_VAL_47_E2N_id_RANfunctionsDeleted = 60008;
 426 static const long asn_VAL_47_E2N_reject = 0;
 427 static const long asn_VAL_47_E2N_optional = 0;
 428 static const asn_ioc_cell_t asn_IOS_E2N_RICserviceUpdate_IEs_1_rows[] = {
 429         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_45_E2N_id_RANfunctionsAdded },
 430         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_45_E2N_reject },
 431         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctions_List },
 432         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_45_E2N_optional },
 433         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_46_E2N_id_RANfunctionsModified },
 434         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_46_E2N_reject },
 435         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctions_List },
 436         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_46_E2N_optional },
 437         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_47_E2N_id_RANfunctionsDeleted },
 438         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_47_E2N_reject },
 439         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionsID_List },
 440         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_47_E2N_optional }
 441 };
 442 static const asn_ioc_set_t asn_IOS_E2N_RICserviceUpdate_IEs_1[] = {
 443         { 3, 4, asn_IOS_E2N_RICserviceUpdate_IEs_1_rows }
 444 };
 445 static const long asn_VAL_50_E2N_id_RANfunctionsAccepted = 60006;
 446 static const long asn_VAL_50_E2N_reject = 0;
 447 static const long asn_VAL_50_E2N_optional = 0;
 448 static const long asn_VAL_51_E2N_id_RANfunctionsRejected = 60010;
 449 static const long asn_VAL_51_E2N_reject = 0;
 450 static const long asn_VAL_51_E2N_optional = 0;
 451 static const asn_ioc_cell_t asn_IOS_E2N_RICserviceUpdateAcknowledge_IEs_1_rows[] = {
 452         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_50_E2N_id_RANfunctionsAccepted },
 453         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_50_E2N_reject },
 454         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionsID_List },
 455         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_50_E2N_optional },
 456         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_51_E2N_id_RANfunctionsRejected },
 457         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_51_E2N_reject },
 458         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionsIDcause_List },
 459         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_51_E2N_optional }
 460 };
 461 static const asn_ioc_set_t asn_IOS_E2N_RICserviceUpdateAcknowledge_IEs_1[] = {
 462         { 2, 4, asn_IOS_E2N_RICserviceUpdateAcknowledge_IEs_1_rows }
 463 };
 464 static const long asn_VAL_53_E2N_id_RANfunctionsRejected = 60010;
 465 static const long asn_VAL_53_E2N_ignore = 1;
 466 static const long asn_VAL_53_E2N_optional = 0;
 467 static const long asn_VAL_54_E2N_id_TimeToWait = 22;
 468 static const long asn_VAL_54_E2N_ignore = 1;
 469 static const long asn_VAL_54_E2N_optional = 0;
 470 static const long asn_VAL_55_E2N_id_CriticalityDiagnostics = 17;
 471 static const long asn_VAL_55_E2N_ignore = 1;
 472 static const long asn_VAL_55_E2N_optional = 0;
 473 static const asn_ioc_cell_t asn_IOS_E2N_RICserviceUpdateFailure_IEs_1_rows[] = {
 474         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_53_E2N_id_RANfunctionsRejected },
 475         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_53_E2N_ignore },
 476         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionsIDcause_List },
 477         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_53_E2N_optional },
 478         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_54_E2N_id_TimeToWait },
 479         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_54_E2N_ignore },
 480         { "&Value", aioc__type, &asn_DEF_E2N_TimeToWait },
 481         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_54_E2N_optional },
 482         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_55_E2N_id_CriticalityDiagnostics },
 483         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_55_E2N_ignore },
 484         { "&Value", aioc__type, &asn_DEF_E2N_CriticalityDiagnostics },
 485         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_55_E2N_optional }
 486 };
 487 static const asn_ioc_set_t asn_IOS_E2N_RICserviceUpdateFailure_IEs_1[] = {
 488         { 3, 4, asn_IOS_E2N_RICserviceUpdateFailure_IEs_1_rows }
 489 };
 490 static const long asn_VAL_56_E2N_id_RANfunctionsAccepted = 60006;
 491 static const long asn_VAL_56_E2N_reject = 0;
 492 static const long asn_VAL_56_E2N_optional = 0;
 493 static const asn_ioc_cell_t asn_IOS_E2N_RICserviceQuery_IEs_1_rows[] = {
 494         { "&id", aioc__value, &asn_DEF_E2N_ProtocolIE_ID, &asn_VAL_56_E2N_id_RANfunctionsAccepted },
 495         { "&criticality", aioc__value, &asn_DEF_E2N_Criticality, &asn_VAL_56_E2N_reject },
 496         { "&Value", aioc__type, &asn_DEF_E2N_RANfunctionsID_List },
 497         { "&presence", aioc__value, &asn_DEF_E2N_Presence, &asn_VAL_56_E2N_optional }
 498 };
 499 static const asn_ioc_set_t asn_IOS_E2N_RICserviceQuery_IEs_1[] = {
 500         { 1, 4, asn_IOS_E2N_RICserviceQuery_IEs_1_rows }
 501 };
 502 static int
 503 memb_E2N_id_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 504                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 505         long value;
 506
 507         if(!sptr) {
 508                 ASN__CTFAIL(app_key, td, sptr,
 509                         "%s: value not given (%s:%d)",
 510                         td->name, __FILE__, __LINE__);
 511                 return -1;
 512         }
 513
 514         value = *(const long *)sptr;
 515
 516         if((value >= 0 && value <= 65535)) {
 517                 /* Constraint check succeeded */
 518                 return 0;
 519         } else {
 520                 ASN__CTFAIL(app_key, td, sptr,
 521                         "%s: constraint failed (%s:%d)",
 522                         td->name, __FILE__, __LINE__);
 523                 return -1;
 524         }
 525 }
 526
 527 static asn_type_selector_result_t
 528 select_RICaction_ToBeSetup_ItemIEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 529         asn_type_selector_result_t result = {0, 0};
 530         const asn_ioc_set_t *itable = asn_IOS_E2N_RICaction_ToBeSetup_ItemIEs_1;
 531         size_t constraining_column = 0; /* &id */
 532         size_t for_column = 1; /* &criticality */
 533         size_t row, presence_index = 0;
 534         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs, id));
 535
 536         for(row=0; row < itable->rows_count; row++) {
 537             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 538             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 539
 540             if(type_cell->cell_kind == aioc__undefined)
 541                 continue;
 542
 543             presence_index++;
 544             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 545                 result.type_descriptor = type_cell->type_descriptor;
 546                 result.presence_index = presence_index;
 547                 break;
 548             }
 549         }
 550
 551         return result;
 552 }
 553
 554 static int
 555 memb_E2N_criticality_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 556                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 557
 558         if(!sptr) {
 559                 ASN__CTFAIL(app_key, td, sptr,
 560                         "%s: value not given (%s:%d)",
 561                         td->name, __FILE__, __LINE__);
 562                 return -1;
 563         }
 564
 565
 566         if(1 /* No applicable constraints whatsoever */) {
 567                 /* Nothing is here. See below */
 568         }
 569
 570         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 571 }
 572
 573 static asn_type_selector_result_t
 574 select_RICaction_ToBeSetup_ItemIEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 575         asn_type_selector_result_t result = {0, 0};
 576         const asn_ioc_set_t *itable = asn_IOS_E2N_RICaction_ToBeSetup_ItemIEs_1;
 577         size_t constraining_column = 0; /* &id */
 578         size_t for_column = 2; /* &Value */
 579         size_t row, presence_index = 0;
 580         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs, id));
 581
 582         for(row=0; row < itable->rows_count; row++) {
 583             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 584             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 585
 586             if(type_cell->cell_kind == aioc__undefined)
 587                 continue;
 588
 589             presence_index++;
 590             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 591                 result.type_descriptor = type_cell->type_descriptor;
 592                 result.presence_index = presence_index;
 593                 break;
 594             }
 595         }
 596
 597         return result;
 598 }
 599
 600 static int
 601 memb_E2N_value_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 602                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 603
 604         if(!sptr) {
 605                 ASN__CTFAIL(app_key, td, sptr,
 606                         "%s: value not given (%s:%d)",
 607                         td->name, __FILE__, __LINE__);
 608                 return -1;
 609         }
 610
 611
 612         if(1 /* No applicable constraints whatsoever */) {
 613                 /* Nothing is here. See below */
 614         }
 615
 616         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 617 }
 618
 619 static int
 620 memb_E2N_id_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 621                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 622         long value;
 623
 624         if(!sptr) {
 625                 ASN__CTFAIL(app_key, td, sptr,
 626                         "%s: value not given (%s:%d)",
 627                         td->name, __FILE__, __LINE__);
 628                 return -1;
 629         }
 630
 631         value = *(const long *)sptr;
 632
 633         if((value >= 0 && value <= 65535)) {
 634                 /* Constraint check succeeded */
 635                 return 0;
 636         } else {
 637                 ASN__CTFAIL(app_key, td, sptr,
 638                         "%s: constraint failed (%s:%d)",
 639                         td->name, __FILE__, __LINE__);
 640                 return -1;
 641         }
 642 }
 643
 644 static asn_type_selector_result_t
 645 select_RICaction_Admitted_ItemIEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 646         asn_type_selector_result_t result = {0, 0};
 647         const asn_ioc_set_t *itable = asn_IOS_E2N_RICaction_Admitted_ItemIEs_1;
 648         size_t constraining_column = 0; /* &id */
 649         size_t for_column = 1; /* &criticality */
 650         size_t row, presence_index = 0;
 651         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICaction_Admitted_ItemIEs, id));
 652
 653         for(row=0; row < itable->rows_count; row++) {
 654             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 655             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 656
 657             if(type_cell->cell_kind == aioc__undefined)
 658                 continue;
 659
 660             presence_index++;
 661             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 662                 result.type_descriptor = type_cell->type_descriptor;
 663                 result.presence_index = presence_index;
 664                 break;
 665             }
 666         }
 667
 668         return result;
 669 }
 670
 671 static int
 672 memb_E2N_criticality_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 673                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 674
 675         if(!sptr) {
 676                 ASN__CTFAIL(app_key, td, sptr,
 677                         "%s: value not given (%s:%d)",
 678                         td->name, __FILE__, __LINE__);
 679                 return -1;
 680         }
 681
 682
 683         if(1 /* No applicable constraints whatsoever */) {
 684                 /* Nothing is here. See below */
 685         }
 686
 687         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 688 }
 689
 690 static asn_type_selector_result_t
 691 select_RICaction_Admitted_ItemIEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 692         asn_type_selector_result_t result = {0, 0};
 693         const asn_ioc_set_t *itable = asn_IOS_E2N_RICaction_Admitted_ItemIEs_1;
 694         size_t constraining_column = 0; /* &id */
 695         size_t for_column = 2; /* &Value */
 696         size_t row, presence_index = 0;
 697         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICaction_Admitted_ItemIEs, id));
 698
 699         for(row=0; row < itable->rows_count; row++) {
 700             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 701             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 702
 703             if(type_cell->cell_kind == aioc__undefined)
 704                 continue;
 705
 706             presence_index++;
 707             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 708                 result.type_descriptor = type_cell->type_descriptor;
 709                 result.presence_index = presence_index;
 710                 break;
 711             }
 712         }
 713
 714         return result;
 715 }
 716
 717 static int
 718 memb_E2N_value_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 719                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 720
 721         if(!sptr) {
 722                 ASN__CTFAIL(app_key, td, sptr,
 723                         "%s: value not given (%s:%d)",
 724                         td->name, __FILE__, __LINE__);
 725                 return -1;
 726         }
 727
 728
 729         if(1 /* No applicable constraints whatsoever */) {
 730                 /* Nothing is here. See below */
 731         }
 732
 733         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 734 }
 735
 736 static int
 737 memb_E2N_id_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 738                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 739         long value;
 740
 741         if(!sptr) {
 742                 ASN__CTFAIL(app_key, td, sptr,
 743                         "%s: value not given (%s:%d)",
 744                         td->name, __FILE__, __LINE__);
 745                 return -1;
 746         }
 747
 748         value = *(const long *)sptr;
 749
 750         if((value >= 0 && value <= 65535)) {
 751                 /* Constraint check succeeded */
 752                 return 0;
 753         } else {
 754                 ASN__CTFAIL(app_key, td, sptr,
 755                         "%s: constraint failed (%s:%d)",
 756                         td->name, __FILE__, __LINE__);
 757                 return -1;
 758         }
 759 }
 760
 761 static asn_type_selector_result_t
 762 select_RICaction_NotAdmitted_ItemIEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 763         asn_type_selector_result_t result = {0, 0};
 764         const asn_ioc_set_t *itable = asn_IOS_E2N_RICaction_NotAdmitted_ItemIEs_1;
 765         size_t constraining_column = 0; /* &id */
 766         size_t for_column = 1; /* &criticality */
 767         size_t row, presence_index = 0;
 768         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs, id));
 769
 770         for(row=0; row < itable->rows_count; row++) {
 771             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 772             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 773
 774             if(type_cell->cell_kind == aioc__undefined)
 775                 continue;
 776
 777             presence_index++;
 778             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 779                 result.type_descriptor = type_cell->type_descriptor;
 780                 result.presence_index = presence_index;
 781                 break;
 782             }
 783         }
 784
 785         return result;
 786 }
 787
 788 static int
 789 memb_E2N_criticality_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 790                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 791
 792         if(!sptr) {
 793                 ASN__CTFAIL(app_key, td, sptr,
 794                         "%s: value not given (%s:%d)",
 795                         td->name, __FILE__, __LINE__);
 796                 return -1;
 797         }
 798
 799
 800         if(1 /* No applicable constraints whatsoever */) {
 801                 /* Nothing is here. See below */
 802         }
 803
 804         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 805 }
 806
 807 static asn_type_selector_result_t
 808 select_RICaction_NotAdmitted_ItemIEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 809         asn_type_selector_result_t result = {0, 0};
 810         const asn_ioc_set_t *itable = asn_IOS_E2N_RICaction_NotAdmitted_ItemIEs_1;
 811         size_t constraining_column = 0; /* &id */
 812         size_t for_column = 2; /* &Value */
 813         size_t row, presence_index = 0;
 814         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs, id));
 815
 816         for(row=0; row < itable->rows_count; row++) {
 817             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 818             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 819
 820             if(type_cell->cell_kind == aioc__undefined)
 821                 continue;
 822
 823             presence_index++;
 824             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 825                 result.type_descriptor = type_cell->type_descriptor;
 826                 result.presence_index = presence_index;
 827                 break;
 828             }
 829         }
 830
 831         return result;
 832 }
 833
 834 static int
 835 memb_E2N_value_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 836                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 837
 838         if(!sptr) {
 839                 ASN__CTFAIL(app_key, td, sptr,
 840                         "%s: value not given (%s:%d)",
 841                         td->name, __FILE__, __LINE__);
 842                 return -1;
 843         }
 844
 845
 846         if(1 /* No applicable constraints whatsoever */) {
 847                 /* Nothing is here. See below */
 848         }
 849
 850         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 851 }
 852
 853 static int
 854 memb_E2N_id_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
 855                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 856         long value;
 857
 858         if(!sptr) {
 859                 ASN__CTFAIL(app_key, td, sptr,
 860                         "%s: value not given (%s:%d)",
 861                         td->name, __FILE__, __LINE__);
 862                 return -1;
 863         }
 864
 865         value = *(const long *)sptr;
 866
 867         if((value >= 0 && value <= 65535)) {
 868                 /* Constraint check succeeded */
 869                 return 0;
 870         } else {
 871                 ASN__CTFAIL(app_key, td, sptr,
 872                         "%s: constraint failed (%s:%d)",
 873                         td->name, __FILE__, __LINE__);
 874                 return -1;
 875         }
 876 }
 877
 878 static asn_type_selector_result_t
 879 select_RANfunction_ItemIEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 880         asn_type_selector_result_t result = {0, 0};
 881         const asn_ioc_set_t *itable = asn_IOS_E2N_RANfunction_ItemIEs_1;
 882         size_t constraining_column = 0; /* &id */
 883         size_t for_column = 1; /* &criticality */
 884         size_t row, presence_index = 0;
 885         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RANfunction_ItemIEs, id));
 886
 887         for(row=0; row < itable->rows_count; row++) {
 888             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 889             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 890
 891             if(type_cell->cell_kind == aioc__undefined)
 892                 continue;
 893
 894             presence_index++;
 895             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 896                 result.type_descriptor = type_cell->type_descriptor;
 897                 result.presence_index = presence_index;
 898                 break;
 899             }
 900         }
 901
 902         return result;
 903 }
 904
 905 static int
 906 memb_E2N_criticality_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
 907                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 908
 909         if(!sptr) {
 910                 ASN__CTFAIL(app_key, td, sptr,
 911                         "%s: value not given (%s:%d)",
 912                         td->name, __FILE__, __LINE__);
 913                 return -1;
 914         }
 915
 916
 917         if(1 /* No applicable constraints whatsoever */) {
 918                 /* Nothing is here. See below */
 919         }
 920
 921         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 922 }
 923
 924 static asn_type_selector_result_t
 925 select_RANfunction_ItemIEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 926         asn_type_selector_result_t result = {0, 0};
 927         const asn_ioc_set_t *itable = asn_IOS_E2N_RANfunction_ItemIEs_1;
 928         size_t constraining_column = 0; /* &id */
 929         size_t for_column = 2; /* &Value */
 930         size_t row, presence_index = 0;
 931         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RANfunction_ItemIEs, id));
 932
 933         for(row=0; row < itable->rows_count; row++) {
 934             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 935             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 936
 937             if(type_cell->cell_kind == aioc__undefined)
 938                 continue;
 939
 940             presence_index++;
 941             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 942                 result.type_descriptor = type_cell->type_descriptor;
 943                 result.presence_index = presence_index;
 944                 break;
 945             }
 946         }
 947
 948         return result;
 949 }
 950
 951 static int
 952 memb_E2N_value_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
 953                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 954
 955         if(!sptr) {
 956                 ASN__CTFAIL(app_key, td, sptr,
 957                         "%s: value not given (%s:%d)",
 958                         td->name, __FILE__, __LINE__);
 959                 return -1;
 960         }
 961
 962
 963         if(1 /* No applicable constraints whatsoever */) {
 964                 /* Nothing is here. See below */
 965         }
 966
 967         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 968 }
 969
 970 static int
 971 memb_E2N_id_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
 972                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 973         long value;
 974
 975         if(!sptr) {
 976                 ASN__CTFAIL(app_key, td, sptr,
 977                         "%s: value not given (%s:%d)",
 978                         td->name, __FILE__, __LINE__);
 979                 return -1;
 980         }
 981
 982         value = *(const long *)sptr;
 983
 984         if((value >= 0 && value <= 65535)) {
 985                 /* Constraint check succeeded */
 986                 return 0;
 987         } else {
 988                 ASN__CTFAIL(app_key, td, sptr,
 989                         "%s: constraint failed (%s:%d)",
 990                         td->name, __FILE__, __LINE__);
 991                 return -1;
 992         }
 993 }
 994
 995 static asn_type_selector_result_t
 996 select_RANfunctionID_ItemIEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 997         asn_type_selector_result_t result = {0, 0};
 998         const asn_ioc_set_t *itable = asn_IOS_E2N_RANfunctionID_ItemIEs_1;
 999         size_t constraining_column = 0; /* &id */
1000         size_t for_column = 1; /* &criticality */
1001         size_t row, presence_index = 0;
1002         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RANfunctionID_ItemIEs, id));
1003
1004         for(row=0; row < itable->rows_count; row++) {
1005             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1006             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1007
1008             if(type_cell->cell_kind == aioc__undefined)
1009                 continue;
1010
1011             presence_index++;
1012             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1013                 result.type_descriptor = type_cell->type_descriptor;
1014                 result.presence_index = presence_index;
1015                 break;
1016             }
1017         }
1018
1019         return result;
1020 }
1021
1022 static int
1023 memb_E2N_criticality_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1024                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1025
1026         if(!sptr) {
1027                 ASN__CTFAIL(app_key, td, sptr,
1028                         "%s: value not given (%s:%d)",
1029                         td->name, __FILE__, __LINE__);
1030                 return -1;
1031         }
1032
1033
1034         if(1 /* No applicable constraints whatsoever */) {
1035                 /* Nothing is here. See below */
1036         }
1037
1038         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1039 }
1040
1041 static asn_type_selector_result_t
1042 select_RANfunctionID_ItemIEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1043         asn_type_selector_result_t result = {0, 0};
1044         const asn_ioc_set_t *itable = asn_IOS_E2N_RANfunctionID_ItemIEs_1;
1045         size_t constraining_column = 0; /* &id */
1046         size_t for_column = 2; /* &Value */
1047         size_t row, presence_index = 0;
1048         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RANfunctionID_ItemIEs, id));
1049
1050         for(row=0; row < itable->rows_count; row++) {
1051             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1052             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1053
1054             if(type_cell->cell_kind == aioc__undefined)
1055                 continue;
1056
1057             presence_index++;
1058             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1059                 result.type_descriptor = type_cell->type_descriptor;
1060                 result.presence_index = presence_index;
1061                 break;
1062             }
1063         }
1064
1065         return result;
1066 }
1067
1068 static int
1069 memb_E2N_value_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1070                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1071
1072         if(!sptr) {
1073                 ASN__CTFAIL(app_key, td, sptr,
1074                         "%s: value not given (%s:%d)",
1075                         td->name, __FILE__, __LINE__);
1076                 return -1;
1077         }
1078
1079
1080         if(1 /* No applicable constraints whatsoever */) {
1081                 /* Nothing is here. See below */
1082         }
1083
1084         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1085 }
1086
1087 static int
1088 memb_E2N_id_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1089                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1090         long value;
1091
1092         if(!sptr) {
1093                 ASN__CTFAIL(app_key, td, sptr,
1094                         "%s: value not given (%s:%d)",
1095                         td->name, __FILE__, __LINE__);
1096                 return -1;
1097         }
1098
1099         value = *(const long *)sptr;
1100
1101         if((value >= 0 && value <= 65535)) {
1102                 /* Constraint check succeeded */
1103                 return 0;
1104         } else {
1105                 ASN__CTFAIL(app_key, td, sptr,
1106                         "%s: constraint failed (%s:%d)",
1107                         td->name, __FILE__, __LINE__);
1108                 return -1;
1109         }
1110 }
1111
1112 static asn_type_selector_result_t
1113 select_RANfunctionIDcause_ItemIEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1114         asn_type_selector_result_t result = {0, 0};
1115         const asn_ioc_set_t *itable = asn_IOS_E2N_RANfunctionIDcause_ItemIEs_1;
1116         size_t constraining_column = 0; /* &id */
1117         size_t for_column = 1; /* &criticality */
1118         size_t row, presence_index = 0;
1119         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RANfunctionIDcause_ItemIEs, id));
1120
1121         for(row=0; row < itable->rows_count; row++) {
1122             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1123             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1124
1125             if(type_cell->cell_kind == aioc__undefined)
1126                 continue;
1127
1128             presence_index++;
1129             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1130                 result.type_descriptor = type_cell->type_descriptor;
1131                 result.presence_index = presence_index;
1132                 break;
1133             }
1134         }
1135
1136         return result;
1137 }
1138
1139 static int
1140 memb_E2N_criticality_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1141                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1142
1143         if(!sptr) {
1144                 ASN__CTFAIL(app_key, td, sptr,
1145                         "%s: value not given (%s:%d)",
1146                         td->name, __FILE__, __LINE__);
1147                 return -1;
1148         }
1149
1150
1151         if(1 /* No applicable constraints whatsoever */) {
1152                 /* Nothing is here. See below */
1153         }
1154
1155         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1156 }
1157
1158 static asn_type_selector_result_t
1159 select_RANfunctionIDcause_ItemIEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1160         asn_type_selector_result_t result = {0, 0};
1161         const asn_ioc_set_t *itable = asn_IOS_E2N_RANfunctionIDcause_ItemIEs_1;
1162         size_t constraining_column = 0; /* &id */
1163         size_t for_column = 2; /* &Value */
1164         size_t row, presence_index = 0;
1165         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RANfunctionIDcause_ItemIEs, id));
1166
1167         for(row=0; row < itable->rows_count; row++) {
1168             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1169             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1170
1171             if(type_cell->cell_kind == aioc__undefined)
1172                 continue;
1173
1174             presence_index++;
1175             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1176                 result.type_descriptor = type_cell->type_descriptor;
1177                 result.presence_index = presence_index;
1178                 break;
1179             }
1180         }
1181
1182         return result;
1183 }
1184
1185 static int
1186 memb_E2N_value_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1187                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1188
1189         if(!sptr) {
1190                 ASN__CTFAIL(app_key, td, sptr,
1191                         "%s: value not given (%s:%d)",
1192                         td->name, __FILE__, __LINE__);
1193                 return -1;
1194         }
1195
1196
1197         if(1 /* No applicable constraints whatsoever */) {
1198                 /* Nothing is here. See below */
1199         }
1200
1201         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1202 }
1203
1204 static int
1205 memb_E2N_id_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1206                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1207         long value;
1208
1209         if(!sptr) {
1210                 ASN__CTFAIL(app_key, td, sptr,
1211                         "%s: value not given (%s:%d)",
1212                         td->name, __FILE__, __LINE__);
1213                 return -1;
1214         }
1215
1216         value = *(const long *)sptr;
1217
1218         if((value >= 0 && value <= 65535)) {
1219                 /* Constraint check succeeded */
1220                 return 0;
1221         } else {
1222                 ASN__CTFAIL(app_key, td, sptr,
1223                         "%s: constraint failed (%s:%d)",
1224                         td->name, __FILE__, __LINE__);
1225                 return -1;
1226         }
1227 }
1228
1229 static asn_type_selector_result_t
1230 select_RICsubscriptionRequest_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1231         asn_type_selector_result_t result = {0, 0};
1232         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionRequest_IEs_1;
1233         size_t constraining_column = 0; /* &id */
1234         size_t for_column = 1; /* &criticality */
1235         size_t row, presence_index = 0;
1236         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionRequest_IEs, id));
1237
1238         for(row=0; row < itable->rows_count; row++) {
1239             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1240             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1241
1242             if(type_cell->cell_kind == aioc__undefined)
1243                 continue;
1244
1245             presence_index++;
1246             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1247                 result.type_descriptor = type_cell->type_descriptor;
1248                 result.presence_index = presence_index;
1249                 break;
1250             }
1251         }
1252
1253         return result;
1254 }
1255
1256 static int
1257 memb_E2N_criticality_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1258                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1259
1260         if(!sptr) {
1261                 ASN__CTFAIL(app_key, td, sptr,
1262                         "%s: value not given (%s:%d)",
1263                         td->name, __FILE__, __LINE__);
1264                 return -1;
1265         }
1266
1267
1268         if(1 /* No applicable constraints whatsoever */) {
1269                 /* Nothing is here. See below */
1270         }
1271
1272         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1273 }
1274
1275 static asn_type_selector_result_t
1276 select_RICsubscriptionRequest_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1277         asn_type_selector_result_t result = {0, 0};
1278         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionRequest_IEs_1;
1279         size_t constraining_column = 0; /* &id */
1280         size_t for_column = 2; /* &Value */
1281         size_t row, presence_index = 0;
1282         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionRequest_IEs, id));
1283
1284         for(row=0; row < itable->rows_count; row++) {
1285             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1286             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1287
1288             if(type_cell->cell_kind == aioc__undefined)
1289                 continue;
1290
1291             presence_index++;
1292             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1293                 result.type_descriptor = type_cell->type_descriptor;
1294                 result.presence_index = presence_index;
1295                 break;
1296             }
1297         }
1298
1299         return result;
1300 }
1301
1302 static int
1303 memb_E2N_value_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1304                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1305
1306         if(!sptr) {
1307                 ASN__CTFAIL(app_key, td, sptr,
1308                         "%s: value not given (%s:%d)",
1309                         td->name, __FILE__, __LINE__);
1310                 return -1;
1311         }
1312
1313
1314         if(1 /* No applicable constraints whatsoever */) {
1315                 /* Nothing is here. See below */
1316         }
1317
1318         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1319 }
1320
1321 static int
1322 memb_E2N_id_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1323                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1324         long value;
1325
1326         if(!sptr) {
1327                 ASN__CTFAIL(app_key, td, sptr,
1328                         "%s: value not given (%s:%d)",
1329                         td->name, __FILE__, __LINE__);
1330                 return -1;
1331         }
1332
1333         value = *(const long *)sptr;
1334
1335         if((value >= 0 && value <= 65535)) {
1336                 /* Constraint check succeeded */
1337                 return 0;
1338         } else {
1339                 ASN__CTFAIL(app_key, td, sptr,
1340                         "%s: constraint failed (%s:%d)",
1341                         td->name, __FILE__, __LINE__);
1342                 return -1;
1343         }
1344 }
1345
1346 static asn_type_selector_result_t
1347 select_RICsubscriptionResponse_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1348         asn_type_selector_result_t result = {0, 0};
1349         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionResponse_IEs_1;
1350         size_t constraining_column = 0; /* &id */
1351         size_t for_column = 1; /* &criticality */
1352         size_t row, presence_index = 0;
1353         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionResponse_IEs, id));
1354
1355         for(row=0; row < itable->rows_count; row++) {
1356             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1357             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1358
1359             if(type_cell->cell_kind == aioc__undefined)
1360                 continue;
1361
1362             presence_index++;
1363             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1364                 result.type_descriptor = type_cell->type_descriptor;
1365                 result.presence_index = presence_index;
1366                 break;
1367             }
1368         }
1369
1370         return result;
1371 }
1372
1373 static int
1374 memb_E2N_criticality_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1375                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1376
1377         if(!sptr) {
1378                 ASN__CTFAIL(app_key, td, sptr,
1379                         "%s: value not given (%s:%d)",
1380                         td->name, __FILE__, __LINE__);
1381                 return -1;
1382         }
1383
1384
1385         if(1 /* No applicable constraints whatsoever */) {
1386                 /* Nothing is here. See below */
1387         }
1388
1389         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1390 }
1391
1392 static asn_type_selector_result_t
1393 select_RICsubscriptionResponse_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1394         asn_type_selector_result_t result = {0, 0};
1395         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionResponse_IEs_1;
1396         size_t constraining_column = 0; /* &id */
1397         size_t for_column = 2; /* &Value */
1398         size_t row, presence_index = 0;
1399         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionResponse_IEs, id));
1400
1401         for(row=0; row < itable->rows_count; row++) {
1402             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1403             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1404
1405             if(type_cell->cell_kind == aioc__undefined)
1406                 continue;
1407
1408             presence_index++;
1409             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1410                 result.type_descriptor = type_cell->type_descriptor;
1411                 result.presence_index = presence_index;
1412                 break;
1413             }
1414         }
1415
1416         return result;
1417 }
1418
1419 static int
1420 memb_E2N_value_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1421                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1422
1423         if(!sptr) {
1424                 ASN__CTFAIL(app_key, td, sptr,
1425                         "%s: value not given (%s:%d)",
1426                         td->name, __FILE__, __LINE__);
1427                 return -1;
1428         }
1429
1430
1431         if(1 /* No applicable constraints whatsoever */) {
1432                 /* Nothing is here. See below */
1433         }
1434
1435         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1436 }
1437
1438 static int
1439 memb_E2N_id_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1440                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1441         long value;
1442
1443         if(!sptr) {
1444                 ASN__CTFAIL(app_key, td, sptr,
1445                         "%s: value not given (%s:%d)",
1446                         td->name, __FILE__, __LINE__);
1447                 return -1;
1448         }
1449
1450         value = *(const long *)sptr;
1451
1452         if((value >= 0 && value <= 65535)) {
1453                 /* Constraint check succeeded */
1454                 return 0;
1455         } else {
1456                 ASN__CTFAIL(app_key, td, sptr,
1457                         "%s: constraint failed (%s:%d)",
1458                         td->name, __FILE__, __LINE__);
1459                 return -1;
1460         }
1461 }
1462
1463 static asn_type_selector_result_t
1464 select_RICsubscriptionFailure_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1465         asn_type_selector_result_t result = {0, 0};
1466         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionFailure_IEs_1;
1467         size_t constraining_column = 0; /* &id */
1468         size_t for_column = 1; /* &criticality */
1469         size_t row, presence_index = 0;
1470         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionFailure_IEs, id));
1471
1472         for(row=0; row < itable->rows_count; row++) {
1473             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1474             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1475
1476             if(type_cell->cell_kind == aioc__undefined)
1477                 continue;
1478
1479             presence_index++;
1480             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1481                 result.type_descriptor = type_cell->type_descriptor;
1482                 result.presence_index = presence_index;
1483                 break;
1484             }
1485         }
1486
1487         return result;
1488 }
1489
1490 static int
1491 memb_E2N_criticality_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1492                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1493
1494         if(!sptr) {
1495                 ASN__CTFAIL(app_key, td, sptr,
1496                         "%s: value not given (%s:%d)",
1497                         td->name, __FILE__, __LINE__);
1498                 return -1;
1499         }
1500
1501
1502         if(1 /* No applicable constraints whatsoever */) {
1503                 /* Nothing is here. See below */
1504         }
1505
1506         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1507 }
1508
1509 static asn_type_selector_result_t
1510 select_RICsubscriptionFailure_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1511         asn_type_selector_result_t result = {0, 0};
1512         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionFailure_IEs_1;
1513         size_t constraining_column = 0; /* &id */
1514         size_t for_column = 2; /* &Value */
1515         size_t row, presence_index = 0;
1516         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionFailure_IEs, id));
1517
1518         for(row=0; row < itable->rows_count; row++) {
1519             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1520             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1521
1522             if(type_cell->cell_kind == aioc__undefined)
1523                 continue;
1524
1525             presence_index++;
1526             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1527                 result.type_descriptor = type_cell->type_descriptor;
1528                 result.presence_index = presence_index;
1529                 break;
1530             }
1531         }
1532
1533         return result;
1534 }
1535
1536 static int
1537 memb_E2N_value_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1538                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1539
1540         if(!sptr) {
1541                 ASN__CTFAIL(app_key, td, sptr,
1542                         "%s: value not given (%s:%d)",
1543                         td->name, __FILE__, __LINE__);
1544                 return -1;
1545         }
1546
1547
1548         if(1 /* No applicable constraints whatsoever */) {
1549                 /* Nothing is here. See below */
1550         }
1551
1552         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1553 }
1554
1555 static int
1556 memb_E2N_id_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1557                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1558         long value;
1559
1560         if(!sptr) {
1561                 ASN__CTFAIL(app_key, td, sptr,
1562                         "%s: value not given (%s:%d)",
1563                         td->name, __FILE__, __LINE__);
1564                 return -1;
1565         }
1566
1567         value = *(const long *)sptr;
1568
1569         if((value >= 0 && value <= 65535)) {
1570                 /* Constraint check succeeded */
1571                 return 0;
1572         } else {
1573                 ASN__CTFAIL(app_key, td, sptr,
1574                         "%s: constraint failed (%s:%d)",
1575                         td->name, __FILE__, __LINE__);
1576                 return -1;
1577         }
1578 }
1579
1580 static asn_type_selector_result_t
1581 select_RICsubscriptionDeleteRequest_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1582         asn_type_selector_result_t result = {0, 0};
1583         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionDeleteRequest_IEs_1;
1584         size_t constraining_column = 0; /* &id */
1585         size_t for_column = 1; /* &criticality */
1586         size_t row, presence_index = 0;
1587         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs, id));
1588
1589         for(row=0; row < itable->rows_count; row++) {
1590             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1591             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1592
1593             if(type_cell->cell_kind == aioc__undefined)
1594                 continue;
1595
1596             presence_index++;
1597             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1598                 result.type_descriptor = type_cell->type_descriptor;
1599                 result.presence_index = presence_index;
1600                 break;
1601             }
1602         }
1603
1604         return result;
1605 }
1606
1607 static int
1608 memb_E2N_criticality_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1609                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1610
1611         if(!sptr) {
1612                 ASN__CTFAIL(app_key, td, sptr,
1613                         "%s: value not given (%s:%d)",
1614                         td->name, __FILE__, __LINE__);
1615                 return -1;
1616         }
1617
1618
1619         if(1 /* No applicable constraints whatsoever */) {
1620                 /* Nothing is here. See below */
1621         }
1622
1623         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1624 }
1625
1626 static asn_type_selector_result_t
1627 select_RICsubscriptionDeleteRequest_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1628         asn_type_selector_result_t result = {0, 0};
1629         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionDeleteRequest_IEs_1;
1630         size_t constraining_column = 0; /* &id */
1631         size_t for_column = 2; /* &Value */
1632         size_t row, presence_index = 0;
1633         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs, id));
1634
1635         for(row=0; row < itable->rows_count; row++) {
1636             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1637             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1638
1639             if(type_cell->cell_kind == aioc__undefined)
1640                 continue;
1641
1642             presence_index++;
1643             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1644                 result.type_descriptor = type_cell->type_descriptor;
1645                 result.presence_index = presence_index;
1646                 break;
1647             }
1648         }
1649
1650         return result;
1651 }
1652
1653 static int
1654 memb_E2N_value_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1655                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1656
1657         if(!sptr) {
1658                 ASN__CTFAIL(app_key, td, sptr,
1659                         "%s: value not given (%s:%d)",
1660                         td->name, __FILE__, __LINE__);
1661                 return -1;
1662         }
1663
1664
1665         if(1 /* No applicable constraints whatsoever */) {
1666                 /* Nothing is here. See below */
1667         }
1668
1669         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1670 }
1671
1672 static int
1673 memb_E2N_id_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1674                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1675         long value;
1676
1677         if(!sptr) {
1678                 ASN__CTFAIL(app_key, td, sptr,
1679                         "%s: value not given (%s:%d)",
1680                         td->name, __FILE__, __LINE__);
1681                 return -1;
1682         }
1683
1684         value = *(const long *)sptr;
1685
1686         if((value >= 0 && value <= 65535)) {
1687                 /* Constraint check succeeded */
1688                 return 0;
1689         } else {
1690                 ASN__CTFAIL(app_key, td, sptr,
1691                         "%s: constraint failed (%s:%d)",
1692                         td->name, __FILE__, __LINE__);
1693                 return -1;
1694         }
1695 }
1696
1697 static asn_type_selector_result_t
1698 select_RICsubscriptionDeleteResponse_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1699         asn_type_selector_result_t result = {0, 0};
1700         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionDeleteResponse_IEs_1;
1701         size_t constraining_column = 0; /* &id */
1702         size_t for_column = 1; /* &criticality */
1703         size_t row, presence_index = 0;
1704         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs, id));
1705
1706         for(row=0; row < itable->rows_count; row++) {
1707             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1708             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1709
1710             if(type_cell->cell_kind == aioc__undefined)
1711                 continue;
1712
1713             presence_index++;
1714             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1715                 result.type_descriptor = type_cell->type_descriptor;
1716                 result.presence_index = presence_index;
1717                 break;
1718             }
1719         }
1720
1721         return result;
1722 }
1723
1724 static int
1725 memb_E2N_criticality_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1726                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1727
1728         if(!sptr) {
1729                 ASN__CTFAIL(app_key, td, sptr,
1730                         "%s: value not given (%s:%d)",
1731                         td->name, __FILE__, __LINE__);
1732                 return -1;
1733         }
1734
1735
1736         if(1 /* No applicable constraints whatsoever */) {
1737                 /* Nothing is here. See below */
1738         }
1739
1740         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1741 }
1742
1743 static asn_type_selector_result_t
1744 select_RICsubscriptionDeleteResponse_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1745         asn_type_selector_result_t result = {0, 0};
1746         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionDeleteResponse_IEs_1;
1747         size_t constraining_column = 0; /* &id */
1748         size_t for_column = 2; /* &Value */
1749         size_t row, presence_index = 0;
1750         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs, id));
1751
1752         for(row=0; row < itable->rows_count; row++) {
1753             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1754             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1755
1756             if(type_cell->cell_kind == aioc__undefined)
1757                 continue;
1758
1759             presence_index++;
1760             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1761                 result.type_descriptor = type_cell->type_descriptor;
1762                 result.presence_index = presence_index;
1763                 break;
1764             }
1765         }
1766
1767         return result;
1768 }
1769
1770 static int
1771 memb_E2N_value_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1772                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1773
1774         if(!sptr) {
1775                 ASN__CTFAIL(app_key, td, sptr,
1776                         "%s: value not given (%s:%d)",
1777                         td->name, __FILE__, __LINE__);
1778                 return -1;
1779         }
1780
1781
1782         if(1 /* No applicable constraints whatsoever */) {
1783                 /* Nothing is here. See below */
1784         }
1785
1786         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1787 }
1788
1789 static int
1790 memb_E2N_id_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
1791                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1792         long value;
1793
1794         if(!sptr) {
1795                 ASN__CTFAIL(app_key, td, sptr,
1796                         "%s: value not given (%s:%d)",
1797                         td->name, __FILE__, __LINE__);
1798                 return -1;
1799         }
1800
1801         value = *(const long *)sptr;
1802
1803         if((value >= 0 && value <= 65535)) {
1804                 /* Constraint check succeeded */
1805                 return 0;
1806         } else {
1807                 ASN__CTFAIL(app_key, td, sptr,
1808                         "%s: constraint failed (%s:%d)",
1809                         td->name, __FILE__, __LINE__);
1810                 return -1;
1811         }
1812 }
1813
1814 static asn_type_selector_result_t
1815 select_RICsubscriptionDeleteFailure_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1816         asn_type_selector_result_t result = {0, 0};
1817         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionDeleteFailure_IEs_1;
1818         size_t constraining_column = 0; /* &id */
1819         size_t for_column = 1; /* &criticality */
1820         size_t row, presence_index = 0;
1821         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs, id));
1822
1823         for(row=0; row < itable->rows_count; row++) {
1824             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1825             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1826
1827             if(type_cell->cell_kind == aioc__undefined)
1828                 continue;
1829
1830             presence_index++;
1831             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1832                 result.type_descriptor = type_cell->type_descriptor;
1833                 result.presence_index = presence_index;
1834                 break;
1835             }
1836         }
1837
1838         return result;
1839 }
1840
1841 static int
1842 memb_E2N_criticality_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
1843                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1844
1845         if(!sptr) {
1846                 ASN__CTFAIL(app_key, td, sptr,
1847                         "%s: value not given (%s:%d)",
1848                         td->name, __FILE__, __LINE__);
1849                 return -1;
1850         }
1851
1852
1853         if(1 /* No applicable constraints whatsoever */) {
1854                 /* Nothing is here. See below */
1855         }
1856
1857         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1858 }
1859
1860 static asn_type_selector_result_t
1861 select_RICsubscriptionDeleteFailure_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1862         asn_type_selector_result_t result = {0, 0};
1863         const asn_ioc_set_t *itable = asn_IOS_E2N_RICsubscriptionDeleteFailure_IEs_1;
1864         size_t constraining_column = 0; /* &id */
1865         size_t for_column = 2; /* &Value */
1866         size_t row, presence_index = 0;
1867         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs, id));
1868
1869         for(row=0; row < itable->rows_count; row++) {
1870             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1871             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1872
1873             if(type_cell->cell_kind == aioc__undefined)
1874                 continue;
1875
1876             presence_index++;
1877             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1878                 result.type_descriptor = type_cell->type_descriptor;
1879                 result.presence_index = presence_index;
1880                 break;
1881             }
1882         }
1883
1884         return result;
1885 }
1886
1887 static int
1888 memb_E2N_value_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
1889                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1890
1891         if(!sptr) {
1892                 ASN__CTFAIL(app_key, td, sptr,
1893                         "%s: value not given (%s:%d)",
1894                         td->name, __FILE__, __LINE__);
1895                 return -1;
1896         }
1897
1898
1899         if(1 /* No applicable constraints whatsoever */) {
1900                 /* Nothing is here. See below */
1901         }
1902
1903         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1904 }
1905
1906 static int
1907 memb_E2N_id_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
1908                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1909         long value;
1910
1911         if(!sptr) {
1912                 ASN__CTFAIL(app_key, td, sptr,
1913                         "%s: value not given (%s:%d)",
1914                         td->name, __FILE__, __LINE__);
1915                 return -1;
1916         }
1917
1918         value = *(const long *)sptr;
1919
1920         if((value >= 0 && value <= 65535)) {
1921                 /* Constraint check succeeded */
1922                 return 0;
1923         } else {
1924                 ASN__CTFAIL(app_key, td, sptr,
1925                         "%s: constraint failed (%s:%d)",
1926                         td->name, __FILE__, __LINE__);
1927                 return -1;
1928         }
1929 }
1930
1931 static asn_type_selector_result_t
1932 select_RICindication_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1933         asn_type_selector_result_t result = {0, 0};
1934         const asn_ioc_set_t *itable = asn_IOS_E2N_RICindication_IEs_1;
1935         size_t constraining_column = 0; /* &id */
1936         size_t for_column = 1; /* &criticality */
1937         size_t row, presence_index = 0;
1938         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICindication_IEs, id));
1939
1940         for(row=0; row < itable->rows_count; row++) {
1941             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1942             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1943
1944             if(type_cell->cell_kind == aioc__undefined)
1945                 continue;
1946
1947             presence_index++;
1948             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1949                 result.type_descriptor = type_cell->type_descriptor;
1950                 result.presence_index = presence_index;
1951                 break;
1952             }
1953         }
1954
1955         return result;
1956 }
1957
1958 static int
1959 memb_E2N_criticality_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
1960                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1961
1962         if(!sptr) {
1963                 ASN__CTFAIL(app_key, td, sptr,
1964                         "%s: value not given (%s:%d)",
1965                         td->name, __FILE__, __LINE__);
1966                 return -1;
1967         }
1968
1969
1970         if(1 /* No applicable constraints whatsoever */) {
1971                 /* Nothing is here. See below */
1972         }
1973
1974         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1975 }
1976
1977 static asn_type_selector_result_t
1978 select_RICindication_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1979         asn_type_selector_result_t result = {0, 0};
1980         const asn_ioc_set_t *itable = asn_IOS_E2N_RICindication_IEs_1;
1981         size_t constraining_column = 0; /* &id */
1982         size_t for_column = 2; /* &Value */
1983         size_t row, presence_index = 0;
1984         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICindication_IEs, id));
1985
1986         for(row=0; row < itable->rows_count; row++) {
1987             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1988             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1989
1990             if(type_cell->cell_kind == aioc__undefined)
1991                 continue;
1992
1993             presence_index++;
1994             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1995                 result.type_descriptor = type_cell->type_descriptor;
1996                 result.presence_index = presence_index;
1997                 break;
1998             }
1999         }
2000
2001         return result;
2002 }
2003
2004 static int
2005 memb_E2N_value_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2006                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2007
2008         if(!sptr) {
2009                 ASN__CTFAIL(app_key, td, sptr,
2010                         "%s: value not given (%s:%d)",
2011                         td->name, __FILE__, __LINE__);
2012                 return -1;
2013         }
2014
2015
2016         if(1 /* No applicable constraints whatsoever */) {
2017                 /* Nothing is here. See below */
2018         }
2019
2020         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2021 }
2022
2023 static int
2024 memb_E2N_id_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2025                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2026         long value;
2027
2028         if(!sptr) {
2029                 ASN__CTFAIL(app_key, td, sptr,
2030                         "%s: value not given (%s:%d)",
2031                         td->name, __FILE__, __LINE__);
2032                 return -1;
2033         }
2034
2035         value = *(const long *)sptr;
2036
2037         if((value >= 0 && value <= 65535)) {
2038                 /* Constraint check succeeded */
2039                 return 0;
2040         } else {
2041                 ASN__CTFAIL(app_key, td, sptr,
2042                         "%s: constraint failed (%s:%d)",
2043                         td->name, __FILE__, __LINE__);
2044                 return -1;
2045         }
2046 }
2047
2048 static asn_type_selector_result_t
2049 select_RICcontrolRequest_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2050         asn_type_selector_result_t result = {0, 0};
2051         const asn_ioc_set_t *itable = asn_IOS_E2N_RICcontrolRequest_IEs_1;
2052         size_t constraining_column = 0; /* &id */
2053         size_t for_column = 1; /* &criticality */
2054         size_t row, presence_index = 0;
2055         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICcontrolRequest_IEs, id));
2056
2057         for(row=0; row < itable->rows_count; row++) {
2058             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2059             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2060
2061             if(type_cell->cell_kind == aioc__undefined)
2062                 continue;
2063
2064             presence_index++;
2065             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2066                 result.type_descriptor = type_cell->type_descriptor;
2067                 result.presence_index = presence_index;
2068                 break;
2069             }
2070         }
2071
2072         return result;
2073 }
2074
2075 static int
2076 memb_E2N_criticality_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2077                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2078
2079         if(!sptr) {
2080                 ASN__CTFAIL(app_key, td, sptr,
2081                         "%s: value not given (%s:%d)",
2082                         td->name, __FILE__, __LINE__);
2083                 return -1;
2084         }
2085
2086
2087         if(1 /* No applicable constraints whatsoever */) {
2088                 /* Nothing is here. See below */
2089         }
2090
2091         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2092 }
2093
2094 static asn_type_selector_result_t
2095 select_RICcontrolRequest_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2096         asn_type_selector_result_t result = {0, 0};
2097         const asn_ioc_set_t *itable = asn_IOS_E2N_RICcontrolRequest_IEs_1;
2098         size_t constraining_column = 0; /* &id */
2099         size_t for_column = 2; /* &Value */
2100         size_t row, presence_index = 0;
2101         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICcontrolRequest_IEs, id));
2102
2103         for(row=0; row < itable->rows_count; row++) {
2104             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2105             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2106
2107             if(type_cell->cell_kind == aioc__undefined)
2108                 continue;
2109
2110             presence_index++;
2111             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2112                 result.type_descriptor = type_cell->type_descriptor;
2113                 result.presence_index = presence_index;
2114                 break;
2115             }
2116         }
2117
2118         return result;
2119 }
2120
2121 static int
2122 memb_E2N_value_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2123                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2124
2125         if(!sptr) {
2126                 ASN__CTFAIL(app_key, td, sptr,
2127                         "%s: value not given (%s:%d)",
2128                         td->name, __FILE__, __LINE__);
2129                 return -1;
2130         }
2131
2132
2133         if(1 /* No applicable constraints whatsoever */) {
2134                 /* Nothing is here. See below */
2135         }
2136
2137         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2138 }
2139
2140 static int
2141 memb_E2N_id_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2142                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2143         long value;
2144
2145         if(!sptr) {
2146                 ASN__CTFAIL(app_key, td, sptr,
2147                         "%s: value not given (%s:%d)",
2148                         td->name, __FILE__, __LINE__);
2149                 return -1;
2150         }
2151
2152         value = *(const long *)sptr;
2153
2154         if((value >= 0 && value <= 65535)) {
2155                 /* Constraint check succeeded */
2156                 return 0;
2157         } else {
2158                 ASN__CTFAIL(app_key, td, sptr,
2159                         "%s: constraint failed (%s:%d)",
2160                         td->name, __FILE__, __LINE__);
2161                 return -1;
2162         }
2163 }
2164
2165 static asn_type_selector_result_t
2166 select_RICcontrolAcknowledge_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2167         asn_type_selector_result_t result = {0, 0};
2168         const asn_ioc_set_t *itable = asn_IOS_E2N_RICcontrolAcknowledge_IEs_1;
2169         size_t constraining_column = 0; /* &id */
2170         size_t for_column = 1; /* &criticality */
2171         size_t row, presence_index = 0;
2172         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICcontrolAcknowledge_IEs, id));
2173
2174         for(row=0; row < itable->rows_count; row++) {
2175             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2176             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2177
2178             if(type_cell->cell_kind == aioc__undefined)
2179                 continue;
2180
2181             presence_index++;
2182             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2183                 result.type_descriptor = type_cell->type_descriptor;
2184                 result.presence_index = presence_index;
2185                 break;
2186             }
2187         }
2188
2189         return result;
2190 }
2191
2192 static int
2193 memb_E2N_criticality_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2194                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2195
2196         if(!sptr) {
2197                 ASN__CTFAIL(app_key, td, sptr,
2198                         "%s: value not given (%s:%d)",
2199                         td->name, __FILE__, __LINE__);
2200                 return -1;
2201         }
2202
2203
2204         if(1 /* No applicable constraints whatsoever */) {
2205                 /* Nothing is here. See below */
2206         }
2207
2208         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2209 }
2210
2211 static asn_type_selector_result_t
2212 select_RICcontrolAcknowledge_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2213         asn_type_selector_result_t result = {0, 0};
2214         const asn_ioc_set_t *itable = asn_IOS_E2N_RICcontrolAcknowledge_IEs_1;
2215         size_t constraining_column = 0; /* &id */
2216         size_t for_column = 2; /* &Value */
2217         size_t row, presence_index = 0;
2218         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICcontrolAcknowledge_IEs, id));
2219
2220         for(row=0; row < itable->rows_count; row++) {
2221             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2222             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2223
2224             if(type_cell->cell_kind == aioc__undefined)
2225                 continue;
2226
2227             presence_index++;
2228             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2229                 result.type_descriptor = type_cell->type_descriptor;
2230                 result.presence_index = presence_index;
2231                 break;
2232             }
2233         }
2234
2235         return result;
2236 }
2237
2238 static int
2239 memb_E2N_value_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2240                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2241
2242         if(!sptr) {
2243                 ASN__CTFAIL(app_key, td, sptr,
2244                         "%s: value not given (%s:%d)",
2245                         td->name, __FILE__, __LINE__);
2246                 return -1;
2247         }
2248
2249
2250         if(1 /* No applicable constraints whatsoever */) {
2251                 /* Nothing is here. See below */
2252         }
2253
2254         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2255 }
2256
2257 static int
2258 memb_E2N_id_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2259                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2260         long value;
2261
2262         if(!sptr) {
2263                 ASN__CTFAIL(app_key, td, sptr,
2264                         "%s: value not given (%s:%d)",
2265                         td->name, __FILE__, __LINE__);
2266                 return -1;
2267         }
2268
2269         value = *(const long *)sptr;
2270
2271         if((value >= 0 && value <= 65535)) {
2272                 /* Constraint check succeeded */
2273                 return 0;
2274         } else {
2275                 ASN__CTFAIL(app_key, td, sptr,
2276                         "%s: constraint failed (%s:%d)",
2277                         td->name, __FILE__, __LINE__);
2278                 return -1;
2279         }
2280 }
2281
2282 static asn_type_selector_result_t
2283 select_RICcontrolFailure_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2284         asn_type_selector_result_t result = {0, 0};
2285         const asn_ioc_set_t *itable = asn_IOS_E2N_RICcontrolFailure_IEs_1;
2286         size_t constraining_column = 0; /* &id */
2287         size_t for_column = 1; /* &criticality */
2288         size_t row, presence_index = 0;
2289         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICcontrolFailure_IEs, id));
2290
2291         for(row=0; row < itable->rows_count; row++) {
2292             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2293             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2294
2295             if(type_cell->cell_kind == aioc__undefined)
2296                 continue;
2297
2298             presence_index++;
2299             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2300                 result.type_descriptor = type_cell->type_descriptor;
2301                 result.presence_index = presence_index;
2302                 break;
2303             }
2304         }
2305
2306         return result;
2307 }
2308
2309 static int
2310 memb_E2N_criticality_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2311                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2312
2313         if(!sptr) {
2314                 ASN__CTFAIL(app_key, td, sptr,
2315                         "%s: value not given (%s:%d)",
2316                         td->name, __FILE__, __LINE__);
2317                 return -1;
2318         }
2319
2320
2321         if(1 /* No applicable constraints whatsoever */) {
2322                 /* Nothing is here. See below */
2323         }
2324
2325         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2326 }
2327
2328 static asn_type_selector_result_t
2329 select_RICcontrolFailure_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2330         asn_type_selector_result_t result = {0, 0};
2331         const asn_ioc_set_t *itable = asn_IOS_E2N_RICcontrolFailure_IEs_1;
2332         size_t constraining_column = 0; /* &id */
2333         size_t for_column = 2; /* &Value */
2334         size_t row, presence_index = 0;
2335         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICcontrolFailure_IEs, id));
2336
2337         for(row=0; row < itable->rows_count; row++) {
2338             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2339             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2340
2341             if(type_cell->cell_kind == aioc__undefined)
2342                 continue;
2343
2344             presence_index++;
2345             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2346                 result.type_descriptor = type_cell->type_descriptor;
2347                 result.presence_index = presence_index;
2348                 break;
2349             }
2350         }
2351
2352         return result;
2353 }
2354
2355 static int
2356 memb_E2N_value_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2357                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2358
2359         if(!sptr) {
2360                 ASN__CTFAIL(app_key, td, sptr,
2361                         "%s: value not given (%s:%d)",
2362                         td->name, __FILE__, __LINE__);
2363                 return -1;
2364         }
2365
2366
2367         if(1 /* No applicable constraints whatsoever */) {
2368                 /* Nothing is here. See below */
2369         }
2370
2371         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2372 }
2373
2374 static int
2375 memb_E2N_id_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2376                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2377         long value;
2378
2379         if(!sptr) {
2380                 ASN__CTFAIL(app_key, td, sptr,
2381                         "%s: value not given (%s:%d)",
2382                         td->name, __FILE__, __LINE__);
2383                 return -1;
2384         }
2385
2386         value = *(const long *)sptr;
2387
2388         if((value >= 0 && value <= 65535)) {
2389                 /* Constraint check succeeded */
2390                 return 0;
2391         } else {
2392                 ASN__CTFAIL(app_key, td, sptr,
2393                         "%s: constraint failed (%s:%d)",
2394                         td->name, __FILE__, __LINE__);
2395                 return -1;
2396         }
2397 }
2398
2399 static asn_type_selector_result_t
2400 select_RICserviceUpdate_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2401         asn_type_selector_result_t result = {0, 0};
2402         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceUpdate_IEs_1;
2403         size_t constraining_column = 0; /* &id */
2404         size_t for_column = 1; /* &criticality */
2405         size_t row, presence_index = 0;
2406         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceUpdate_IEs, id));
2407
2408         for(row=0; row < itable->rows_count; row++) {
2409             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2410             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2411
2412             if(type_cell->cell_kind == aioc__undefined)
2413                 continue;
2414
2415             presence_index++;
2416             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2417                 result.type_descriptor = type_cell->type_descriptor;
2418                 result.presence_index = presence_index;
2419                 break;
2420             }
2421         }
2422
2423         return result;
2424 }
2425
2426 static int
2427 memb_E2N_criticality_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2428                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2429
2430         if(!sptr) {
2431                 ASN__CTFAIL(app_key, td, sptr,
2432                         "%s: value not given (%s:%d)",
2433                         td->name, __FILE__, __LINE__);
2434                 return -1;
2435         }
2436
2437
2438         if(1 /* No applicable constraints whatsoever */) {
2439                 /* Nothing is here. See below */
2440         }
2441
2442         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2443 }
2444
2445 static asn_type_selector_result_t
2446 select_RICserviceUpdate_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2447         asn_type_selector_result_t result = {0, 0};
2448         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceUpdate_IEs_1;
2449         size_t constraining_column = 0; /* &id */
2450         size_t for_column = 2; /* &Value */
2451         size_t row, presence_index = 0;
2452         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceUpdate_IEs, id));
2453         const int indexToPresence[4] = {
2454                 E2N_RICserviceUpdate_IEs__value_PR_NOTHING,
2455                 E2N_RICserviceUpdate_IEs__value_PR_RANfunctions_List,
2456                 E2N_RICserviceUpdate_IEs__value_PR_RANfunctions_List,
2457                 E2N_RICserviceUpdate_IEs__value_PR_RANfunctionsID_List
2458         };
2459
2460         for(row=0; row < itable->rows_count; row++) {
2461             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2462             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2463
2464             if(type_cell->cell_kind == aioc__undefined)
2465                 continue;
2466
2467             presence_index++;
2468             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2469                 result.type_descriptor = type_cell->type_descriptor;
2470                 result.presence_index = indexToPresence[presence_index];
2471                 break;
2472             }
2473         }
2474
2475         return result;
2476 }
2477
2478 static int
2479 memb_E2N_value_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2480                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2481
2482         if(!sptr) {
2483                 ASN__CTFAIL(app_key, td, sptr,
2484                         "%s: value not given (%s:%d)",
2485                         td->name, __FILE__, __LINE__);
2486                 return -1;
2487         }
2488
2489
2490         if(1 /* No applicable constraints whatsoever */) {
2491                 /* Nothing is here. See below */
2492         }
2493
2494         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2495 }
2496
2497 static int
2498 memb_E2N_id_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2499                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2500         long value;
2501
2502         if(!sptr) {
2503                 ASN__CTFAIL(app_key, td, sptr,
2504                         "%s: value not given (%s:%d)",
2505                         td->name, __FILE__, __LINE__);
2506                 return -1;
2507         }
2508
2509         value = *(const long *)sptr;
2510
2511         if((value >= 0 && value <= 65535)) {
2512                 /* Constraint check succeeded */
2513                 return 0;
2514         } else {
2515                 ASN__CTFAIL(app_key, td, sptr,
2516                         "%s: constraint failed (%s:%d)",
2517                         td->name, __FILE__, __LINE__);
2518                 return -1;
2519         }
2520 }
2521
2522 static asn_type_selector_result_t
2523 select_RICserviceUpdateAcknowledge_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2524         asn_type_selector_result_t result = {0, 0};
2525         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceUpdateAcknowledge_IEs_1;
2526         size_t constraining_column = 0; /* &id */
2527         size_t for_column = 1; /* &criticality */
2528         size_t row, presence_index = 0;
2529         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs, id));
2530
2531         for(row=0; row < itable->rows_count; row++) {
2532             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2533             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2534
2535             if(type_cell->cell_kind == aioc__undefined)
2536                 continue;
2537
2538             presence_index++;
2539             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2540                 result.type_descriptor = type_cell->type_descriptor;
2541                 result.presence_index = presence_index;
2542                 break;
2543             }
2544         }
2545
2546         return result;
2547 }
2548
2549 static int
2550 memb_E2N_criticality_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2551                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2552
2553         if(!sptr) {
2554                 ASN__CTFAIL(app_key, td, sptr,
2555                         "%s: value not given (%s:%d)",
2556                         td->name, __FILE__, __LINE__);
2557                 return -1;
2558         }
2559
2560
2561         if(1 /* No applicable constraints whatsoever */) {
2562                 /* Nothing is here. See below */
2563         }
2564
2565         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2566 }
2567
2568 static asn_type_selector_result_t
2569 select_RICserviceUpdateAcknowledge_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2570         asn_type_selector_result_t result = {0, 0};
2571         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceUpdateAcknowledge_IEs_1;
2572         size_t constraining_column = 0; /* &id */
2573         size_t for_column = 2; /* &Value */
2574         size_t row, presence_index = 0;
2575         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs, id));
2576
2577         for(row=0; row < itable->rows_count; row++) {
2578             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2579             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2580
2581             if(type_cell->cell_kind == aioc__undefined)
2582                 continue;
2583
2584             presence_index++;
2585             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2586                 result.type_descriptor = type_cell->type_descriptor;
2587                 result.presence_index = presence_index;
2588                 break;
2589             }
2590         }
2591
2592         return result;
2593 }
2594
2595 static int
2596 memb_E2N_value_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2597                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2598
2599         if(!sptr) {
2600                 ASN__CTFAIL(app_key, td, sptr,
2601                         "%s: value not given (%s:%d)",
2602                         td->name, __FILE__, __LINE__);
2603                 return -1;
2604         }
2605
2606
2607         if(1 /* No applicable constraints whatsoever */) {
2608                 /* Nothing is here. See below */
2609         }
2610
2611         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2612 }
2613
2614 static int
2615 memb_E2N_id_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2616                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2617         long value;
2618
2619         if(!sptr) {
2620                 ASN__CTFAIL(app_key, td, sptr,
2621                         "%s: value not given (%s:%d)",
2622                         td->name, __FILE__, __LINE__);
2623                 return -1;
2624         }
2625
2626         value = *(const long *)sptr;
2627
2628         if((value >= 0 && value <= 65535)) {
2629                 /* Constraint check succeeded */
2630                 return 0;
2631         } else {
2632                 ASN__CTFAIL(app_key, td, sptr,
2633                         "%s: constraint failed (%s:%d)",
2634                         td->name, __FILE__, __LINE__);
2635                 return -1;
2636         }
2637 }
2638
2639 static asn_type_selector_result_t
2640 select_RICserviceUpdateFailure_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2641         asn_type_selector_result_t result = {0, 0};
2642         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceUpdateFailure_IEs_1;
2643         size_t constraining_column = 0; /* &id */
2644         size_t for_column = 1; /* &criticality */
2645         size_t row, presence_index = 0;
2646         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceUpdateFailure_IEs, id));
2647
2648         for(row=0; row < itable->rows_count; row++) {
2649             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2650             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2651
2652             if(type_cell->cell_kind == aioc__undefined)
2653                 continue;
2654
2655             presence_index++;
2656             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2657                 result.type_descriptor = type_cell->type_descriptor;
2658                 result.presence_index = presence_index;
2659                 break;
2660             }
2661         }
2662
2663         return result;
2664 }
2665
2666 static int
2667 memb_E2N_criticality_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2668                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2669
2670         if(!sptr) {
2671                 ASN__CTFAIL(app_key, td, sptr,
2672                         "%s: value not given (%s:%d)",
2673                         td->name, __FILE__, __LINE__);
2674                 return -1;
2675         }
2676
2677
2678         if(1 /* No applicable constraints whatsoever */) {
2679                 /* Nothing is here. See below */
2680         }
2681
2682         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2683 }
2684
2685 static asn_type_selector_result_t
2686 select_RICserviceUpdateFailure_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2687         asn_type_selector_result_t result = {0, 0};
2688         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceUpdateFailure_IEs_1;
2689         size_t constraining_column = 0; /* &id */
2690         size_t for_column = 2; /* &Value */
2691         size_t row, presence_index = 0;
2692         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceUpdateFailure_IEs, id));
2693
2694         for(row=0; row < itable->rows_count; row++) {
2695             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2696             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2697
2698             if(type_cell->cell_kind == aioc__undefined)
2699                 continue;
2700
2701             presence_index++;
2702             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2703                 result.type_descriptor = type_cell->type_descriptor;
2704                 result.presence_index = presence_index;
2705                 break;
2706             }
2707         }
2708
2709         return result;
2710 }
2711
2712 static int
2713 memb_E2N_value_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2714                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2715
2716         if(!sptr) {
2717                 ASN__CTFAIL(app_key, td, sptr,
2718                         "%s: value not given (%s:%d)",
2719                         td->name, __FILE__, __LINE__);
2720                 return -1;
2721         }
2722
2723
2724         if(1 /* No applicable constraints whatsoever */) {
2725                 /* Nothing is here. See below */
2726         }
2727
2728         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2729 }
2730
2731 static int
2732 memb_E2N_id_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2733                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2734         long value;
2735
2736         if(!sptr) {
2737                 ASN__CTFAIL(app_key, td, sptr,
2738                         "%s: value not given (%s:%d)",
2739                         td->name, __FILE__, __LINE__);
2740                 return -1;
2741         }
2742
2743         value = *(const long *)sptr;
2744
2745         if((value >= 0 && value <= 65535)) {
2746                 /* Constraint check succeeded */
2747                 return 0;
2748         } else {
2749                 ASN__CTFAIL(app_key, td, sptr,
2750                         "%s: constraint failed (%s:%d)",
2751                         td->name, __FILE__, __LINE__);
2752                 return -1;
2753         }
2754 }
2755
2756 static asn_type_selector_result_t
2757 select_RICserviceQuery_IEs_E2N_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2758         asn_type_selector_result_t result = {0, 0};
2759         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceQuery_IEs_1;
2760         size_t constraining_column = 0; /* &id */
2761         size_t for_column = 1; /* &criticality */
2762         size_t row, presence_index = 0;
2763         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceQuery_IEs, id));
2764
2765         for(row=0; row < itable->rows_count; row++) {
2766             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2767             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2768
2769             if(type_cell->cell_kind == aioc__undefined)
2770                 continue;
2771
2772             presence_index++;
2773             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2774                 result.type_descriptor = type_cell->type_descriptor;
2775                 result.presence_index = presence_index;
2776                 break;
2777             }
2778         }
2779
2780         return result;
2781 }
2782
2783 static int
2784 memb_E2N_criticality_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2785                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2786
2787         if(!sptr) {
2788                 ASN__CTFAIL(app_key, td, sptr,
2789                         "%s: value not given (%s:%d)",
2790                         td->name, __FILE__, __LINE__);
2791                 return -1;
2792         }
2793
2794
2795         if(1 /* No applicable constraints whatsoever */) {
2796                 /* Nothing is here. See below */
2797         }
2798
2799         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2800 }
2801
2802 static asn_type_selector_result_t
2803 select_RICserviceQuery_IEs_E2N_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2804         asn_type_selector_result_t result = {0, 0};
2805         const asn_ioc_set_t *itable = asn_IOS_E2N_RICserviceQuery_IEs_1;
2806         size_t constraining_column = 0; /* &id */
2807         size_t for_column = 2; /* &Value */
2808         size_t row, presence_index = 0;
2809         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2N_RICserviceQuery_IEs, id));
2810
2811         for(row=0; row < itable->rows_count; row++) {
2812             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2813             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2814
2815             if(type_cell->cell_kind == aioc__undefined)
2816                 continue;
2817
2818             presence_index++;
2819             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2820                 result.type_descriptor = type_cell->type_descriptor;
2821                 result.presence_index = presence_index;
2822                 break;
2823             }
2824         }
2825
2826         return result;
2827 }
2828
2829 static int
2830 memb_E2N_value_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2831                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2832
2833         if(!sptr) {
2834                 ASN__CTFAIL(app_key, td, sptr,
2835                         "%s: value not given (%s:%d)",
2836                         td->name, __FILE__, __LINE__);
2837                 return -1;
2838         }
2839
2840
2841         if(1 /* No applicable constraints whatsoever */) {
2842                 /* Nothing is here. See below */
2843         }
2844
2845         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2846 }
2847
2848 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_2 CC_NOTUSED = {
2849         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2850         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2851         0, 0    /* No PER value map */
2852 };
2853 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_3 CC_NOTUSED = {
2854         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2855         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2856         0, 0    /* No PER value map */
2857 };
2858 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_4 CC_NOTUSED = {
2859         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2860         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2861         0, 0    /* No PER value map */
2862 };
2863 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_6 CC_NOTUSED = {
2864         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2865         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2866         0, 0    /* No PER value map */
2867 };
2868 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_7 CC_NOTUSED = {
2869         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2870         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2871         0, 0    /* No PER value map */
2872 };
2873 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_8 CC_NOTUSED = {
2874         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2875         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2876         0, 0    /* No PER value map */
2877 };
2878 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_10 CC_NOTUSED = {
2879         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2880         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2881         0, 0    /* No PER value map */
2882 };
2883 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_11 CC_NOTUSED = {
2884         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2885         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2886         0, 0    /* No PER value map */
2887 };
2888 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_12 CC_NOTUSED = {
2889         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2890         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2891         0, 0    /* No PER value map */
2892 };
2893 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_14 CC_NOTUSED = {
2894         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2895         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2896         0, 0    /* No PER value map */
2897 };
2898 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_15 CC_NOTUSED = {
2899         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2900         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2901         0, 0    /* No PER value map */
2902 };
2903 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_16 CC_NOTUSED = {
2904         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2905         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2906         0, 0    /* No PER value map */
2907 };
2908 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_18 CC_NOTUSED = {
2909         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2910         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2911         0, 0    /* No PER value map */
2912 };
2913 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_19 CC_NOTUSED = {
2914         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2915         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2916         0, 0    /* No PER value map */
2917 };
2918 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_20 CC_NOTUSED = {
2919         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2920         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2921         0, 0    /* No PER value map */
2922 };
2923 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_22 CC_NOTUSED = {
2924         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2925         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2926         0, 0    /* No PER value map */
2927 };
2928 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_23 CC_NOTUSED = {
2929         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2930         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2931         0, 0    /* No PER value map */
2932 };
2933 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_24 CC_NOTUSED = {
2934         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2935         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2936         0, 0    /* No PER value map */
2937 };
2938 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_26 CC_NOTUSED = {
2939         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2940         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2941         0, 0    /* No PER value map */
2942 };
2943 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_27 CC_NOTUSED = {
2944         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2945         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2946         0, 0    /* No PER value map */
2947 };
2948 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_28 CC_NOTUSED = {
2949         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2950         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2951         0, 0    /* No PER value map */
2952 };
2953 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_30 CC_NOTUSED = {
2954         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2955         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2956         0, 0    /* No PER value map */
2957 };
2958 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_31 CC_NOTUSED = {
2959         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2960         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2961         0, 0    /* No PER value map */
2962 };
2963 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_32 CC_NOTUSED = {
2964         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2965         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2966         0, 0    /* No PER value map */
2967 };
2968 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_34 CC_NOTUSED = {
2969         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2970         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2971         0, 0    /* No PER value map */
2972 };
2973 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_35 CC_NOTUSED = {
2974         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2975         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2976         0, 0    /* No PER value map */
2977 };
2978 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_36 CC_NOTUSED = {
2979         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2980         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2981         0, 0    /* No PER value map */
2982 };
2983 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_38 CC_NOTUSED = {
2984         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
2985         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2986         0, 0    /* No PER value map */
2987 };
2988 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_39 CC_NOTUSED = {
2989         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
2990         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2991         0, 0    /* No PER value map */
2992 };
2993 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_40 CC_NOTUSED = {
2994         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2995         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
2996         0, 0    /* No PER value map */
2997 };
2998 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_42 CC_NOTUSED = {
2999         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3000         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3001         0, 0    /* No PER value map */
3002 };
3003 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_43 CC_NOTUSED = {
3004         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3005         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3006         0, 0    /* No PER value map */
3007 };
3008 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_44 CC_NOTUSED = {
3009         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3010         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3011         0, 0    /* No PER value map */
3012 };
3013 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_46 CC_NOTUSED = {
3014         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3015         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3016         0, 0    /* No PER value map */
3017 };
3018 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_47 CC_NOTUSED = {
3019         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3020         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3021         0, 0    /* No PER value map */
3022 };
3023 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_48 CC_NOTUSED = {
3024         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3025         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3026         0, 0    /* No PER value map */
3027 };
3028 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_50 CC_NOTUSED = {
3029         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3030         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3031         0, 0    /* No PER value map */
3032 };
3033 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_51 CC_NOTUSED = {
3034         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3035         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3036         0, 0    /* No PER value map */
3037 };
3038 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_52 CC_NOTUSED = {
3039         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3040         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3041         0, 0    /* No PER value map */
3042 };
3043 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_54 CC_NOTUSED = {
3044         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3045         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3046         0, 0    /* No PER value map */
3047 };
3048 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_55 CC_NOTUSED = {
3049         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3050         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3051         0, 0    /* No PER value map */
3052 };
3053 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_56 CC_NOTUSED = {
3054         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3055         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3056         0, 0    /* No PER value map */
3057 };
3058 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_58 CC_NOTUSED = {
3059         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3060         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3061         0, 0    /* No PER value map */
3062 };
3063 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_59 CC_NOTUSED = {
3064         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3065         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3066         0, 0    /* No PER value map */
3067 };
3068 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_60 CC_NOTUSED = {
3069         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3070         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3071         0, 0    /* No PER value map */
3072 };
3073 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_62 CC_NOTUSED = {
3074         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3075         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3076         0, 0    /* No PER value map */
3077 };
3078 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_63 CC_NOTUSED = {
3079         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3080         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3081         0, 0    /* No PER value map */
3082 };
3083 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_64 CC_NOTUSED = {
3084         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3085         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3086         0, 0    /* No PER value map */
3087 };
3088 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_66 CC_NOTUSED = {
3089         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3090         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3091         0, 0    /* No PER value map */
3092 };
3093 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_67 CC_NOTUSED = {
3094         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3095         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3096         0, 0    /* No PER value map */
3097 };
3098 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_68 CC_NOTUSED = {
3099         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3100         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3101         0, 0    /* No PER value map */
3102 };
3103 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_70 CC_NOTUSED = {
3104         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3105         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3106         0, 0    /* No PER value map */
3107 };
3108 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_71 CC_NOTUSED = {
3109         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3110         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3111         0, 0    /* No PER value map */
3112 };
3113 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_72 CC_NOTUSED = {
3114         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3115         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3116         0, 0    /* No PER value map */
3117 };
3118 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_74 CC_NOTUSED = {
3119         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3120         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3121         0, 0    /* No PER value map */
3122 };
3123 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_75 CC_NOTUSED = {
3124         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3125         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3126         0, 0    /* No PER value map */
3127 };
3128 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_76 CC_NOTUSED = {
3129         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3130         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3131         0, 0    /* No PER value map */
3132 };
3133 static asn_per_constraints_t asn_PER_memb_E2N_id_constr_78 CC_NOTUSED = {
3134         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3135         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3136         0, 0    /* No PER value map */
3137 };
3138 static asn_per_constraints_t asn_PER_memb_E2N_criticality_constr_79 CC_NOTUSED = {
3139         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3140         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3141         0, 0    /* No PER value map */
3142 };
3143 static asn_per_constraints_t asn_PER_memb_E2N_value_constr_80 CC_NOTUSED = {
3144         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3145         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3146         0, 0    /* No PER value map */
3147 };
3148 static asn_TYPE_member_t asn_MBR_E2N_value_4[] = {
3149         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs__value, choice.RICaction_ToBeSetup_Item),
3150                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3151                 0,
3152                 &asn_DEF_E2N_RICaction_ToBeSetup_Item,
3153                 0,
3154                 { 0, 0, 0 },
3155                 0, 0, /* No default value */
3156                 "RICaction-ToBeSetup-Item"
3157                 },
3158 };
3159 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_4[] = {
3160     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-ToBeSetup-Item */
3161 };
3162 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_4 = {
3163         sizeof(struct E2N_RICaction_ToBeSetup_ItemIEs__value),
3164         offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs__value, _asn_ctx),
3165         offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs__value, present),
3166         sizeof(((struct E2N_RICaction_ToBeSetup_ItemIEs__value *)0)->present),
3167         asn_MAP_E2N_value_tag2el_4,
3168         1,      /* Count of tags in the map */
3169         0, 0,
3170         -1      /* Extensions start */
3171 };
3172 static /* Use -fall-defs-global to expose */
3173 asn_TYPE_descriptor_t asn_DEF_E2N_value_4 = {
3174         "value",
3175         "value",
3176         &asn_OP_OPEN_TYPE,
3177         0,      /* No effective tags (pointer) */
3178         0,      /* No effective tags (count) */
3179         0,      /* No tags (pointer) */
3180         0,      /* No tags (count) */
3181         { 0, 0, OPEN_TYPE_constraint },
3182         asn_MBR_E2N_value_4,
3183         1,      /* Elements count */
3184         &asn_SPC_E2N_value_specs_4      /* Additional specs */
3185 };
3186
3187 asn_TYPE_member_t asn_MBR_E2N_RICaction_ToBeSetup_ItemIEs_1[] = {
3188         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs, id),
3189                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3190                 -1,     /* IMPLICIT tag at current level */
3191                 &asn_DEF_E2N_ProtocolIE_ID,
3192                 0,
3193                 { 0, &asn_PER_memb_E2N_id_constr_2,  memb_E2N_id_constraint_1 },
3194                 0, 0, /* No default value */
3195                 "id"
3196                 },
3197         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs, criticality),
3198                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3199                 -1,     /* IMPLICIT tag at current level */
3200                 &asn_DEF_E2N_Criticality,
3201                 select_RICaction_ToBeSetup_ItemIEs_E2N_criticality_type,
3202                 { 0, &asn_PER_memb_E2N_criticality_constr_3,  memb_E2N_criticality_constraint_1 },
3203                 0, 0, /* No default value */
3204                 "criticality"
3205                 },
3206         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs, value),
3207                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3208                 +1,     /* EXPLICIT tag at current level */
3209                 &asn_DEF_E2N_value_4,
3210                 select_RICaction_ToBeSetup_ItemIEs_E2N_value_type,
3211                 { 0, &asn_PER_memb_E2N_value_constr_4,  memb_E2N_value_constraint_1 },
3212                 0, 0, /* No default value */
3213                 "value"
3214                 },
3215 };
3216 static const ber_tlv_tag_t asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1[] = {
3217         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3218 };
3219 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICaction_ToBeSetup_ItemIEs_tag2el_1[] = {
3220     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3221     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3222     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3223 };
3224 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICaction_ToBeSetup_ItemIEs_specs_1 = {
3225         sizeof(struct E2N_RICaction_ToBeSetup_ItemIEs),
3226         offsetof(struct E2N_RICaction_ToBeSetup_ItemIEs, _asn_ctx),
3227         asn_MAP_E2N_RICaction_ToBeSetup_ItemIEs_tag2el_1,
3228         3,      /* Count of tags in the map */
3229         0, 0, 0,        /* Optional elements (not needed) */
3230         -1,     /* First extension addition */
3231 };
3232 asn_TYPE_descriptor_t asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs = {
3233         "RICaction-ToBeSetup-ItemIEs",
3234         "RICaction-ToBeSetup-ItemIEs",
3235         &asn_OP_SEQUENCE,
3236         asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1,
3237         sizeof(asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1)
3238                 /sizeof(asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
3239         asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1, /* Same as above */
3240         sizeof(asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1)
3241                 /sizeof(asn_DEF_E2N_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
3242         { 0, 0, SEQUENCE_constraint },
3243         asn_MBR_E2N_RICaction_ToBeSetup_ItemIEs_1,
3244         3,      /* Elements count */
3245         &asn_SPC_E2N_RICaction_ToBeSetup_ItemIEs_specs_1        /* Additional specs */
3246 };
3247
3248 static asn_TYPE_member_t asn_MBR_E2N_value_8[] = {
3249         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_Admitted_ItemIEs__value, choice.RICaction_Admitted_Item),
3250                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3251                 0,
3252                 &asn_DEF_E2N_RICaction_Admitted_Item,
3253                 0,
3254                 { 0, 0, 0 },
3255                 0, 0, /* No default value */
3256                 "RICaction-Admitted-Item"
3257                 },
3258 };
3259 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_8[] = {
3260     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-Admitted-Item */
3261 };
3262 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_8 = {
3263         sizeof(struct E2N_RICaction_Admitted_ItemIEs__value),
3264         offsetof(struct E2N_RICaction_Admitted_ItemIEs__value, _asn_ctx),
3265         offsetof(struct E2N_RICaction_Admitted_ItemIEs__value, present),
3266         sizeof(((struct E2N_RICaction_Admitted_ItemIEs__value *)0)->present),
3267         asn_MAP_E2N_value_tag2el_8,
3268         1,      /* Count of tags in the map */
3269         0, 0,
3270         -1      /* Extensions start */
3271 };
3272 static /* Use -fall-defs-global to expose */
3273 asn_TYPE_descriptor_t asn_DEF_E2N_value_8 = {
3274         "value",
3275         "value",
3276         &asn_OP_OPEN_TYPE,
3277         0,      /* No effective tags (pointer) */
3278         0,      /* No effective tags (count) */
3279         0,      /* No tags (pointer) */
3280         0,      /* No tags (count) */
3281         { 0, 0, OPEN_TYPE_constraint },
3282         asn_MBR_E2N_value_8,
3283         1,      /* Elements count */
3284         &asn_SPC_E2N_value_specs_8      /* Additional specs */
3285 };
3286
3287 asn_TYPE_member_t asn_MBR_E2N_RICaction_Admitted_ItemIEs_5[] = {
3288         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_Admitted_ItemIEs, id),
3289                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3290                 -1,     /* IMPLICIT tag at current level */
3291                 &asn_DEF_E2N_ProtocolIE_ID,
3292                 0,
3293                 { 0, &asn_PER_memb_E2N_id_constr_6,  memb_E2N_id_constraint_5 },
3294                 0, 0, /* No default value */
3295                 "id"
3296                 },
3297         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_Admitted_ItemIEs, criticality),
3298                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3299                 -1,     /* IMPLICIT tag at current level */
3300                 &asn_DEF_E2N_Criticality,
3301                 select_RICaction_Admitted_ItemIEs_E2N_criticality_type,
3302                 { 0, &asn_PER_memb_E2N_criticality_constr_7,  memb_E2N_criticality_constraint_5 },
3303                 0, 0, /* No default value */
3304                 "criticality"
3305                 },
3306         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_Admitted_ItemIEs, value),
3307                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3308                 +1,     /* EXPLICIT tag at current level */
3309                 &asn_DEF_E2N_value_8,
3310                 select_RICaction_Admitted_ItemIEs_E2N_value_type,
3311                 { 0, &asn_PER_memb_E2N_value_constr_8,  memb_E2N_value_constraint_5 },
3312                 0, 0, /* No default value */
3313                 "value"
3314                 },
3315 };
3316 static const ber_tlv_tag_t asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5[] = {
3317         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3318 };
3319 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICaction_Admitted_ItemIEs_tag2el_5[] = {
3320     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3321     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3322     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3323 };
3324 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICaction_Admitted_ItemIEs_specs_5 = {
3325         sizeof(struct E2N_RICaction_Admitted_ItemIEs),
3326         offsetof(struct E2N_RICaction_Admitted_ItemIEs, _asn_ctx),
3327         asn_MAP_E2N_RICaction_Admitted_ItemIEs_tag2el_5,
3328         3,      /* Count of tags in the map */
3329         0, 0, 0,        /* Optional elements (not needed) */
3330         -1,     /* First extension addition */
3331 };
3332 asn_TYPE_descriptor_t asn_DEF_E2N_RICaction_Admitted_ItemIEs = {
3333         "RICaction-Admitted-ItemIEs",
3334         "RICaction-Admitted-ItemIEs",
3335         &asn_OP_SEQUENCE,
3336         asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5,
3337         sizeof(asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5)
3338                 /sizeof(asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
3339         asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5,  /* Same as above */
3340         sizeof(asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5)
3341                 /sizeof(asn_DEF_E2N_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
3342         { 0, 0, SEQUENCE_constraint },
3343         asn_MBR_E2N_RICaction_Admitted_ItemIEs_5,
3344         3,      /* Elements count */
3345         &asn_SPC_E2N_RICaction_Admitted_ItemIEs_specs_5 /* Additional specs */
3346 };
3347
3348 static asn_TYPE_member_t asn_MBR_E2N_value_12[] = {
3349         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs__value, choice.RICaction_NotAdmitted_Item),
3350                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3351                 0,
3352                 &asn_DEF_E2N_RICaction_NotAdmitted_Item,
3353                 0,
3354                 { 0, 0, 0 },
3355                 0, 0, /* No default value */
3356                 "RICaction-NotAdmitted-Item"
3357                 },
3358 };
3359 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_12[] = {
3360     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-NotAdmitted-Item */
3361 };
3362 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_12 = {
3363         sizeof(struct E2N_RICaction_NotAdmitted_ItemIEs__value),
3364         offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs__value, _asn_ctx),
3365         offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs__value, present),
3366         sizeof(((struct E2N_RICaction_NotAdmitted_ItemIEs__value *)0)->present),
3367         asn_MAP_E2N_value_tag2el_12,
3368         1,      /* Count of tags in the map */
3369         0, 0,
3370         -1      /* Extensions start */
3371 };
3372 static /* Use -fall-defs-global to expose */
3373 asn_TYPE_descriptor_t asn_DEF_E2N_value_12 = {
3374         "value",
3375         "value",
3376         &asn_OP_OPEN_TYPE,
3377         0,      /* No effective tags (pointer) */
3378         0,      /* No effective tags (count) */
3379         0,      /* No tags (pointer) */
3380         0,      /* No tags (count) */
3381         { 0, 0, OPEN_TYPE_constraint },
3382         asn_MBR_E2N_value_12,
3383         1,      /* Elements count */
3384         &asn_SPC_E2N_value_specs_12     /* Additional specs */
3385 };
3386
3387 asn_TYPE_member_t asn_MBR_E2N_RICaction_NotAdmitted_ItemIEs_9[] = {
3388         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs, id),
3389                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3390                 -1,     /* IMPLICIT tag at current level */
3391                 &asn_DEF_E2N_ProtocolIE_ID,
3392                 0,
3393                 { 0, &asn_PER_memb_E2N_id_constr_10,  memb_E2N_id_constraint_9 },
3394                 0, 0, /* No default value */
3395                 "id"
3396                 },
3397         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs, criticality),
3398                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3399                 -1,     /* IMPLICIT tag at current level */
3400                 &asn_DEF_E2N_Criticality,
3401                 select_RICaction_NotAdmitted_ItemIEs_E2N_criticality_type,
3402                 { 0, &asn_PER_memb_E2N_criticality_constr_11,  memb_E2N_criticality_constraint_9 },
3403                 0, 0, /* No default value */
3404                 "criticality"
3405                 },
3406         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs, value),
3407                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3408                 +1,     /* EXPLICIT tag at current level */
3409                 &asn_DEF_E2N_value_12,
3410                 select_RICaction_NotAdmitted_ItemIEs_E2N_value_type,
3411                 { 0, &asn_PER_memb_E2N_value_constr_12,  memb_E2N_value_constraint_9 },
3412                 0, 0, /* No default value */
3413                 "value"
3414                 },
3415 };
3416 static const ber_tlv_tag_t asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9[] = {
3417         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3418 };
3419 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICaction_NotAdmitted_ItemIEs_tag2el_9[] = {
3420     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3421     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3422     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3423 };
3424 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICaction_NotAdmitted_ItemIEs_specs_9 = {
3425         sizeof(struct E2N_RICaction_NotAdmitted_ItemIEs),
3426         offsetof(struct E2N_RICaction_NotAdmitted_ItemIEs, _asn_ctx),
3427         asn_MAP_E2N_RICaction_NotAdmitted_ItemIEs_tag2el_9,
3428         3,      /* Count of tags in the map */
3429         0, 0, 0,        /* Optional elements (not needed) */
3430         -1,     /* First extension addition */
3431 };
3432 asn_TYPE_descriptor_t asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs = {
3433         "RICaction-NotAdmitted-ItemIEs",
3434         "RICaction-NotAdmitted-ItemIEs",
3435         &asn_OP_SEQUENCE,
3436         asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9,
3437         sizeof(asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9)
3438                 /sizeof(asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
3439         asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9,       /* Same as above */
3440         sizeof(asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9)
3441                 /sizeof(asn_DEF_E2N_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
3442         { 0, 0, SEQUENCE_constraint },
3443         asn_MBR_E2N_RICaction_NotAdmitted_ItemIEs_9,
3444         3,      /* Elements count */
3445         &asn_SPC_E2N_RICaction_NotAdmitted_ItemIEs_specs_9      /* Additional specs */
3446 };
3447
3448 static asn_TYPE_member_t asn_MBR_E2N_value_16[] = {
3449         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunction_ItemIEs__value, choice.RANfunction_Item),
3450                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3451                 0,
3452                 &asn_DEF_E2N_RANfunction_Item,
3453                 0,
3454                 { 0, 0, 0 },
3455                 0, 0, /* No default value */
3456                 "RANfunction-Item"
3457                 },
3458 };
3459 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_16[] = {
3460     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunction-Item */
3461 };
3462 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_16 = {
3463         sizeof(struct E2N_RANfunction_ItemIEs__value),
3464         offsetof(struct E2N_RANfunction_ItemIEs__value, _asn_ctx),
3465         offsetof(struct E2N_RANfunction_ItemIEs__value, present),
3466         sizeof(((struct E2N_RANfunction_ItemIEs__value *)0)->present),
3467         asn_MAP_E2N_value_tag2el_16,
3468         1,      /* Count of tags in the map */
3469         0, 0,
3470         -1      /* Extensions start */
3471 };
3472 static /* Use -fall-defs-global to expose */
3473 asn_TYPE_descriptor_t asn_DEF_E2N_value_16 = {
3474         "value",
3475         "value",
3476         &asn_OP_OPEN_TYPE,
3477         0,      /* No effective tags (pointer) */
3478         0,      /* No effective tags (count) */
3479         0,      /* No tags (pointer) */
3480         0,      /* No tags (count) */
3481         { 0, 0, OPEN_TYPE_constraint },
3482         asn_MBR_E2N_value_16,
3483         1,      /* Elements count */
3484         &asn_SPC_E2N_value_specs_16     /* Additional specs */
3485 };
3486
3487 asn_TYPE_member_t asn_MBR_E2N_RANfunction_ItemIEs_13[] = {
3488         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunction_ItemIEs, id),
3489                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3490                 -1,     /* IMPLICIT tag at current level */
3491                 &asn_DEF_E2N_ProtocolIE_ID,
3492                 0,
3493                 { 0, &asn_PER_memb_E2N_id_constr_14,  memb_E2N_id_constraint_13 },
3494                 0, 0, /* No default value */
3495                 "id"
3496                 },
3497         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunction_ItemIEs, criticality),
3498                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3499                 -1,     /* IMPLICIT tag at current level */
3500                 &asn_DEF_E2N_Criticality,
3501                 select_RANfunction_ItemIEs_E2N_criticality_type,
3502                 { 0, &asn_PER_memb_E2N_criticality_constr_15,  memb_E2N_criticality_constraint_13 },
3503                 0, 0, /* No default value */
3504                 "criticality"
3505                 },
3506         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunction_ItemIEs, value),
3507                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3508                 +1,     /* EXPLICIT tag at current level */
3509                 &asn_DEF_E2N_value_16,
3510                 select_RANfunction_ItemIEs_E2N_value_type,
3511                 { 0, &asn_PER_memb_E2N_value_constr_16,  memb_E2N_value_constraint_13 },
3512                 0, 0, /* No default value */
3513                 "value"
3514                 },
3515 };
3516 static const ber_tlv_tag_t asn_DEF_E2N_RANfunction_ItemIEs_tags_13[] = {
3517         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3518 };
3519 static const asn_TYPE_tag2member_t asn_MAP_E2N_RANfunction_ItemIEs_tag2el_13[] = {
3520     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3521     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3522     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3523 };
3524 asn_SEQUENCE_specifics_t asn_SPC_E2N_RANfunction_ItemIEs_specs_13 = {
3525         sizeof(struct E2N_RANfunction_ItemIEs),
3526         offsetof(struct E2N_RANfunction_ItemIEs, _asn_ctx),
3527         asn_MAP_E2N_RANfunction_ItemIEs_tag2el_13,
3528         3,      /* Count of tags in the map */
3529         0, 0, 0,        /* Optional elements (not needed) */
3530         -1,     /* First extension addition */
3531 };
3532 asn_TYPE_descriptor_t asn_DEF_E2N_RANfunction_ItemIEs = {
3533         "RANfunction-ItemIEs",
3534         "RANfunction-ItemIEs",
3535         &asn_OP_SEQUENCE,
3536         asn_DEF_E2N_RANfunction_ItemIEs_tags_13,
3537         sizeof(asn_DEF_E2N_RANfunction_ItemIEs_tags_13)
3538                 /sizeof(asn_DEF_E2N_RANfunction_ItemIEs_tags_13[0]), /* 1 */
3539         asn_DEF_E2N_RANfunction_ItemIEs_tags_13,        /* Same as above */
3540         sizeof(asn_DEF_E2N_RANfunction_ItemIEs_tags_13)
3541                 /sizeof(asn_DEF_E2N_RANfunction_ItemIEs_tags_13[0]), /* 1 */
3542         { 0, 0, SEQUENCE_constraint },
3543         asn_MBR_E2N_RANfunction_ItemIEs_13,
3544         3,      /* Elements count */
3545         &asn_SPC_E2N_RANfunction_ItemIEs_specs_13       /* Additional specs */
3546 };
3547
3548 static asn_TYPE_member_t asn_MBR_E2N_value_20[] = {
3549         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionID_ItemIEs__value, choice.RANfunctionID_Item),
3550                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3551                 0,
3552                 &asn_DEF_E2N_RANfunctionID_Item,
3553                 0,
3554                 { 0, 0, 0 },
3555                 0, 0, /* No default value */
3556                 "RANfunctionID-Item"
3557                 },
3558 };
3559 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_20[] = {
3560     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionID-Item */
3561 };
3562 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_20 = {
3563         sizeof(struct E2N_RANfunctionID_ItemIEs__value),
3564         offsetof(struct E2N_RANfunctionID_ItemIEs__value, _asn_ctx),
3565         offsetof(struct E2N_RANfunctionID_ItemIEs__value, present),
3566         sizeof(((struct E2N_RANfunctionID_ItemIEs__value *)0)->present),
3567         asn_MAP_E2N_value_tag2el_20,
3568         1,      /* Count of tags in the map */
3569         0, 0,
3570         -1      /* Extensions start */
3571 };
3572 static /* Use -fall-defs-global to expose */
3573 asn_TYPE_descriptor_t asn_DEF_E2N_value_20 = {
3574         "value",
3575         "value",
3576         &asn_OP_OPEN_TYPE,
3577         0,      /* No effective tags (pointer) */
3578         0,      /* No effective tags (count) */
3579         0,      /* No tags (pointer) */
3580         0,      /* No tags (count) */
3581         { 0, 0, OPEN_TYPE_constraint },
3582         asn_MBR_E2N_value_20,
3583         1,      /* Elements count */
3584         &asn_SPC_E2N_value_specs_20     /* Additional specs */
3585 };
3586
3587 asn_TYPE_member_t asn_MBR_E2N_RANfunctionID_ItemIEs_17[] = {
3588         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionID_ItemIEs, id),
3589                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3590                 -1,     /* IMPLICIT tag at current level */
3591                 &asn_DEF_E2N_ProtocolIE_ID,
3592                 0,
3593                 { 0, &asn_PER_memb_E2N_id_constr_18,  memb_E2N_id_constraint_17 },
3594                 0, 0, /* No default value */
3595                 "id"
3596                 },
3597         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionID_ItemIEs, criticality),
3598                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3599                 -1,     /* IMPLICIT tag at current level */
3600                 &asn_DEF_E2N_Criticality,
3601                 select_RANfunctionID_ItemIEs_E2N_criticality_type,
3602                 { 0, &asn_PER_memb_E2N_criticality_constr_19,  memb_E2N_criticality_constraint_17 },
3603                 0, 0, /* No default value */
3604                 "criticality"
3605                 },
3606         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionID_ItemIEs, value),
3607                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3608                 +1,     /* EXPLICIT tag at current level */
3609                 &asn_DEF_E2N_value_20,
3610                 select_RANfunctionID_ItemIEs_E2N_value_type,
3611                 { 0, &asn_PER_memb_E2N_value_constr_20,  memb_E2N_value_constraint_17 },
3612                 0, 0, /* No default value */
3613                 "value"
3614                 },
3615 };
3616 static const ber_tlv_tag_t asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17[] = {
3617         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3618 };
3619 static const asn_TYPE_tag2member_t asn_MAP_E2N_RANfunctionID_ItemIEs_tag2el_17[] = {
3620     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3621     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3622     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3623 };
3624 asn_SEQUENCE_specifics_t asn_SPC_E2N_RANfunctionID_ItemIEs_specs_17 = {
3625         sizeof(struct E2N_RANfunctionID_ItemIEs),
3626         offsetof(struct E2N_RANfunctionID_ItemIEs, _asn_ctx),
3627         asn_MAP_E2N_RANfunctionID_ItemIEs_tag2el_17,
3628         3,      /* Count of tags in the map */
3629         0, 0, 0,        /* Optional elements (not needed) */
3630         -1,     /* First extension addition */
3631 };
3632 asn_TYPE_descriptor_t asn_DEF_E2N_RANfunctionID_ItemIEs = {
3633         "RANfunctionID-ItemIEs",
3634         "RANfunctionID-ItemIEs",
3635         &asn_OP_SEQUENCE,
3636         asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17,
3637         sizeof(asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17)
3638                 /sizeof(asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
3639         asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17,      /* Same as above */
3640         sizeof(asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17)
3641                 /sizeof(asn_DEF_E2N_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
3642         { 0, 0, SEQUENCE_constraint },
3643         asn_MBR_E2N_RANfunctionID_ItemIEs_17,
3644         3,      /* Elements count */
3645         &asn_SPC_E2N_RANfunctionID_ItemIEs_specs_17     /* Additional specs */
3646 };
3647
3648 static asn_TYPE_member_t asn_MBR_E2N_value_24[] = {
3649         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionIDcause_ItemIEs__value, choice.RANfunctionIDcause_Item),
3650                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3651                 0,
3652                 &asn_DEF_E2N_RANfunctionIDcause_Item,
3653                 0,
3654                 { 0, 0, 0 },
3655                 0, 0, /* No default value */
3656                 "RANfunctionIDcause-Item"
3657                 },
3658 };
3659 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_24[] = {
3660     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionIDcause-Item */
3661 };
3662 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_24 = {
3663         sizeof(struct E2N_RANfunctionIDcause_ItemIEs__value),
3664         offsetof(struct E2N_RANfunctionIDcause_ItemIEs__value, _asn_ctx),
3665         offsetof(struct E2N_RANfunctionIDcause_ItemIEs__value, present),
3666         sizeof(((struct E2N_RANfunctionIDcause_ItemIEs__value *)0)->present),
3667         asn_MAP_E2N_value_tag2el_24,
3668         1,      /* Count of tags in the map */
3669         0, 0,
3670         -1      /* Extensions start */
3671 };
3672 static /* Use -fall-defs-global to expose */
3673 asn_TYPE_descriptor_t asn_DEF_E2N_value_24 = {
3674         "value",
3675         "value",
3676         &asn_OP_OPEN_TYPE,
3677         0,      /* No effective tags (pointer) */
3678         0,      /* No effective tags (count) */
3679         0,      /* No tags (pointer) */
3680         0,      /* No tags (count) */
3681         { 0, 0, OPEN_TYPE_constraint },
3682         asn_MBR_E2N_value_24,
3683         1,      /* Elements count */
3684         &asn_SPC_E2N_value_specs_24     /* Additional specs */
3685 };
3686
3687 asn_TYPE_member_t asn_MBR_E2N_RANfunctionIDcause_ItemIEs_21[] = {
3688         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionIDcause_ItemIEs, id),
3689                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3690                 -1,     /* IMPLICIT tag at current level */
3691                 &asn_DEF_E2N_ProtocolIE_ID,
3692                 0,
3693                 { 0, &asn_PER_memb_E2N_id_constr_22,  memb_E2N_id_constraint_21 },
3694                 0, 0, /* No default value */
3695                 "id"
3696                 },
3697         { ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionIDcause_ItemIEs, criticality),
3698                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3699                 -1,     /* IMPLICIT tag at current level */
3700                 &asn_DEF_E2N_Criticality,
3701                 select_RANfunctionIDcause_ItemIEs_E2N_criticality_type,
3702                 { 0, &asn_PER_memb_E2N_criticality_constr_23,  memb_E2N_criticality_constraint_21 },
3703                 0, 0, /* No default value */
3704                 "criticality"
3705                 },
3706         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RANfunctionIDcause_ItemIEs, value),
3707                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3708                 +1,     /* EXPLICIT tag at current level */
3709                 &asn_DEF_E2N_value_24,
3710                 select_RANfunctionIDcause_ItemIEs_E2N_value_type,
3711                 { 0, &asn_PER_memb_E2N_value_constr_24,  memb_E2N_value_constraint_21 },
3712                 0, 0, /* No default value */
3713                 "value"
3714                 },
3715 };
3716 static const ber_tlv_tag_t asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21[] = {
3717         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3718 };
3719 static const asn_TYPE_tag2member_t asn_MAP_E2N_RANfunctionIDcause_ItemIEs_tag2el_21[] = {
3720     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3721     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3722     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3723 };
3724 asn_SEQUENCE_specifics_t asn_SPC_E2N_RANfunctionIDcause_ItemIEs_specs_21 = {
3725         sizeof(struct E2N_RANfunctionIDcause_ItemIEs),
3726         offsetof(struct E2N_RANfunctionIDcause_ItemIEs, _asn_ctx),
3727         asn_MAP_E2N_RANfunctionIDcause_ItemIEs_tag2el_21,
3728         3,      /* Count of tags in the map */
3729         0, 0, 0,        /* Optional elements (not needed) */
3730         -1,     /* First extension addition */
3731 };
3732 asn_TYPE_descriptor_t asn_DEF_E2N_RANfunctionIDcause_ItemIEs = {
3733         "RANfunctionIDcause-ItemIEs",
3734         "RANfunctionIDcause-ItemIEs",
3735         &asn_OP_SEQUENCE,
3736         asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21,
3737         sizeof(asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21)
3738                 /sizeof(asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
3739         asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21, /* Same as above */
3740         sizeof(asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21)
3741                 /sizeof(asn_DEF_E2N_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
3742         { 0, 0, SEQUENCE_constraint },
3743         asn_MBR_E2N_RANfunctionIDcause_ItemIEs_21,
3744         3,      /* Elements count */
3745         &asn_SPC_E2N_RANfunctionIDcause_ItemIEs_specs_21        /* Additional specs */
3746 };
3747
3748 static asn_TYPE_member_t asn_MBR_E2N_value_28[] = {
3749         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionRequest_IEs__value, choice.RICrequestID),
3750                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3751                 0,
3752                 &asn_DEF_E2N_RICrequestID,
3753                 0,
3754                 { 0, 0, 0 },
3755                 0, 0, /* No default value */
3756                 "RICrequestID"
3757                 },
3758         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionRequest_IEs__value, choice.RANfunctionID),
3759                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
3760                 0,
3761                 &asn_DEF_E2N_RANfunctionID,
3762                 0,
3763                 { 0, 0, 0 },
3764                 0, 0, /* No default value */
3765                 "RANfunctionID"
3766                 },
3767         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionRequest_IEs__value, choice.RICsubscription),
3768                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3769                 0,
3770                 &asn_DEF_E2N_RICsubscription,
3771                 0,
3772                 { 0, 0, 0 },
3773                 0, 0, /* No default value */
3774                 "RICsubscription"
3775                 },
3776 };
3777 static const unsigned asn_MAP_E2N_value_to_canonical_28[] = { 1, 0, 2 };
3778 static const unsigned asn_MAP_E2N_value_from_canonical_28[] = { 1, 0, 2 };
3779 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_28[] = {
3780     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
3781     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
3782     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* RICsubscription */
3783 };
3784 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_28 = {
3785         sizeof(struct E2N_RICsubscriptionRequest_IEs__value),
3786         offsetof(struct E2N_RICsubscriptionRequest_IEs__value, _asn_ctx),
3787         offsetof(struct E2N_RICsubscriptionRequest_IEs__value, present),
3788         sizeof(((struct E2N_RICsubscriptionRequest_IEs__value *)0)->present),
3789         asn_MAP_E2N_value_tag2el_28,
3790         3,      /* Count of tags in the map */
3791         asn_MAP_E2N_value_to_canonical_28,
3792         asn_MAP_E2N_value_from_canonical_28,
3793         -1      /* Extensions start */
3794 };
3795 static /* Use -fall-defs-global to expose */
3796 asn_TYPE_descriptor_t asn_DEF_E2N_value_28 = {
3797         "value",
3798         "value",
3799         &asn_OP_OPEN_TYPE,
3800         0,      /* No effective tags (pointer) */
3801         0,      /* No effective tags (count) */
3802         0,      /* No tags (pointer) */
3803         0,      /* No tags (count) */
3804         { 0, 0, OPEN_TYPE_constraint },
3805         asn_MBR_E2N_value_28,
3806         3,      /* Elements count */
3807         &asn_SPC_E2N_value_specs_28     /* Additional specs */
3808 };
3809
3810 asn_TYPE_member_t asn_MBR_E2N_RICsubscriptionRequest_IEs_25[] = {
3811         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionRequest_IEs, id),
3812                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3813                 -1,     /* IMPLICIT tag at current level */
3814                 &asn_DEF_E2N_ProtocolIE_ID,
3815                 0,
3816                 { 0, &asn_PER_memb_E2N_id_constr_26,  memb_E2N_id_constraint_25 },
3817                 0, 0, /* No default value */
3818                 "id"
3819                 },
3820         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionRequest_IEs, criticality),
3821                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3822                 -1,     /* IMPLICIT tag at current level */
3823                 &asn_DEF_E2N_Criticality,
3824                 select_RICsubscriptionRequest_IEs_E2N_criticality_type,
3825                 { 0, &asn_PER_memb_E2N_criticality_constr_27,  memb_E2N_criticality_constraint_25 },
3826                 0, 0, /* No default value */
3827                 "criticality"
3828                 },
3829         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionRequest_IEs, value),
3830                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3831                 +1,     /* EXPLICIT tag at current level */
3832                 &asn_DEF_E2N_value_28,
3833                 select_RICsubscriptionRequest_IEs_E2N_value_type,
3834                 { 0, &asn_PER_memb_E2N_value_constr_28,  memb_E2N_value_constraint_25 },
3835                 0, 0, /* No default value */
3836                 "value"
3837                 },
3838 };
3839 static const ber_tlv_tag_t asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25[] = {
3840         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3841 };
3842 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICsubscriptionRequest_IEs_tag2el_25[] = {
3843     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3844     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3845     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3846 };
3847 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICsubscriptionRequest_IEs_specs_25 = {
3848         sizeof(struct E2N_RICsubscriptionRequest_IEs),
3849         offsetof(struct E2N_RICsubscriptionRequest_IEs, _asn_ctx),
3850         asn_MAP_E2N_RICsubscriptionRequest_IEs_tag2el_25,
3851         3,      /* Count of tags in the map */
3852         0, 0, 0,        /* Optional elements (not needed) */
3853         -1,     /* First extension addition */
3854 };
3855 asn_TYPE_descriptor_t asn_DEF_E2N_RICsubscriptionRequest_IEs = {
3856         "RICsubscriptionRequest-IEs",
3857         "RICsubscriptionRequest-IEs",
3858         &asn_OP_SEQUENCE,
3859         asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25,
3860         sizeof(asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25)
3861                 /sizeof(asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
3862         asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25, /* Same as above */
3863         sizeof(asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25)
3864                 /sizeof(asn_DEF_E2N_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
3865         { 0, 0, SEQUENCE_constraint },
3866         asn_MBR_E2N_RICsubscriptionRequest_IEs_25,
3867         3,      /* Elements count */
3868         &asn_SPC_E2N_RICsubscriptionRequest_IEs_specs_25        /* Additional specs */
3869 };
3870
3871 static asn_TYPE_member_t asn_MBR_E2N_value_32[] = {
3872         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs__value, choice.RICrequestID),
3873                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3874                 0,
3875                 &asn_DEF_E2N_RICrequestID,
3876                 0,
3877                 { 0, 0, 0 },
3878                 0, 0, /* No default value */
3879                 "RICrequestID"
3880                 },
3881         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs__value, choice.RANfunctionID),
3882                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
3883                 0,
3884                 &asn_DEF_E2N_RANfunctionID,
3885                 0,
3886                 { 0, 0, 0 },
3887                 0, 0, /* No default value */
3888                 "RANfunctionID"
3889                 },
3890         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs__value, choice.RICaction_Admitted_List),
3891                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3892                 0,
3893                 &asn_DEF_E2N_RICaction_Admitted_List,
3894                 0,
3895                 { 0, 0, 0 },
3896                 0, 0, /* No default value */
3897                 "RICaction-Admitted-List"
3898                 },
3899         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs__value, choice.RICaction_NotAdmitted_List),
3900                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
3901                 0,
3902                 &asn_DEF_E2N_RICaction_NotAdmitted_List,
3903                 0,
3904                 { 0, 0, 0 },
3905                 0, 0, /* No default value */
3906                 "RICaction-NotAdmitted-List"
3907                 },
3908 };
3909 static const unsigned asn_MAP_E2N_value_to_canonical_32[] = { 1, 0, 2, 3 };
3910 static const unsigned asn_MAP_E2N_value_from_canonical_32[] = { 1, 0, 2, 3 };
3911 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_32[] = {
3912     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
3913     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
3914     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-Admitted-List */
3915     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* RICaction-NotAdmitted-List */
3916 };
3917 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_32 = {
3918         sizeof(struct E2N_RICsubscriptionResponse_IEs__value),
3919         offsetof(struct E2N_RICsubscriptionResponse_IEs__value, _asn_ctx),
3920         offsetof(struct E2N_RICsubscriptionResponse_IEs__value, present),
3921         sizeof(((struct E2N_RICsubscriptionResponse_IEs__value *)0)->present),
3922         asn_MAP_E2N_value_tag2el_32,
3923         4,      /* Count of tags in the map */
3924         asn_MAP_E2N_value_to_canonical_32,
3925         asn_MAP_E2N_value_from_canonical_32,
3926         -1      /* Extensions start */
3927 };
3928 static /* Use -fall-defs-global to expose */
3929 asn_TYPE_descriptor_t asn_DEF_E2N_value_32 = {
3930         "value",
3931         "value",
3932         &asn_OP_OPEN_TYPE,
3933         0,      /* No effective tags (pointer) */
3934         0,      /* No effective tags (count) */
3935         0,      /* No tags (pointer) */
3936         0,      /* No tags (count) */
3937         { 0, 0, OPEN_TYPE_constraint },
3938         asn_MBR_E2N_value_32,
3939         4,      /* Elements count */
3940         &asn_SPC_E2N_value_specs_32     /* Additional specs */
3941 };
3942
3943 asn_TYPE_member_t asn_MBR_E2N_RICsubscriptionResponse_IEs_29[] = {
3944         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs, id),
3945                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
3946                 -1,     /* IMPLICIT tag at current level */
3947                 &asn_DEF_E2N_ProtocolIE_ID,
3948                 0,
3949                 { 0, &asn_PER_memb_E2N_id_constr_30,  memb_E2N_id_constraint_29 },
3950                 0, 0, /* No default value */
3951                 "id"
3952                 },
3953         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs, criticality),
3954                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
3955                 -1,     /* IMPLICIT tag at current level */
3956                 &asn_DEF_E2N_Criticality,
3957                 select_RICsubscriptionResponse_IEs_E2N_criticality_type,
3958                 { 0, &asn_PER_memb_E2N_criticality_constr_31,  memb_E2N_criticality_constraint_29 },
3959                 0, 0, /* No default value */
3960                 "criticality"
3961                 },
3962         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionResponse_IEs, value),
3963                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
3964                 +1,     /* EXPLICIT tag at current level */
3965                 &asn_DEF_E2N_value_32,
3966                 select_RICsubscriptionResponse_IEs_E2N_value_type,
3967                 { 0, &asn_PER_memb_E2N_value_constr_32,  memb_E2N_value_constraint_29 },
3968                 0, 0, /* No default value */
3969                 "value"
3970                 },
3971 };
3972 static const ber_tlv_tag_t asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29[] = {
3973         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
3974 };
3975 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICsubscriptionResponse_IEs_tag2el_29[] = {
3976     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
3977     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
3978     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
3979 };
3980 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICsubscriptionResponse_IEs_specs_29 = {
3981         sizeof(struct E2N_RICsubscriptionResponse_IEs),
3982         offsetof(struct E2N_RICsubscriptionResponse_IEs, _asn_ctx),
3983         asn_MAP_E2N_RICsubscriptionResponse_IEs_tag2el_29,
3984         3,      /* Count of tags in the map */
3985         0, 0, 0,        /* Optional elements (not needed) */
3986         -1,     /* First extension addition */
3987 };
3988 asn_TYPE_descriptor_t asn_DEF_E2N_RICsubscriptionResponse_IEs = {
3989         "RICsubscriptionResponse-IEs",
3990         "RICsubscriptionResponse-IEs",
3991         &asn_OP_SEQUENCE,
3992         asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29,
3993         sizeof(asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29)
3994                 /sizeof(asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
3995         asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29,        /* Same as above */
3996         sizeof(asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29)
3997                 /sizeof(asn_DEF_E2N_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
3998         { 0, 0, SEQUENCE_constraint },
3999         asn_MBR_E2N_RICsubscriptionResponse_IEs_29,
4000         3,      /* Elements count */
4001         &asn_SPC_E2N_RICsubscriptionResponse_IEs_specs_29       /* Additional specs */
4002 };
4003
4004 static asn_TYPE_member_t asn_MBR_E2N_value_36[] = {
4005         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs__value, choice.RICrequestID),
4006                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4007                 0,
4008                 &asn_DEF_E2N_RICrequestID,
4009                 0,
4010                 { 0, 0, 0 },
4011                 0, 0, /* No default value */
4012                 "RICrequestID"
4013                 },
4014         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs__value, choice.RANfunctionID),
4015                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4016                 0,
4017                 &asn_DEF_E2N_RANfunctionID,
4018                 0,
4019                 { 0, 0, 0 },
4020                 0, 0, /* No default value */
4021                 "RANfunctionID"
4022                 },
4023         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs__value, choice.RICaction_NotAdmitted_List),
4024                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4025                 0,
4026                 &asn_DEF_E2N_RICaction_NotAdmitted_List,
4027                 0,
4028                 { 0, 0, 0 },
4029                 0, 0, /* No default value */
4030                 "RICaction-NotAdmitted-List"
4031                 },
4032         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs__value, choice.CriticalityDiagnostics),
4033                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4034                 0,
4035                 &asn_DEF_E2N_CriticalityDiagnostics,
4036                 0,
4037                 { 0, 0, 0 },
4038                 0, 0, /* No default value */
4039                 "CriticalityDiagnostics"
4040                 },
4041 };
4042 static const unsigned asn_MAP_E2N_value_to_canonical_36[] = { 1, 0, 2, 3 };
4043 static const unsigned asn_MAP_E2N_value_from_canonical_36[] = { 1, 0, 2, 3 };
4044 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_36[] = {
4045     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4046     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
4047     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-NotAdmitted-List */
4048     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* CriticalityDiagnostics */
4049 };
4050 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_36 = {
4051         sizeof(struct E2N_RICsubscriptionFailure_IEs__value),
4052         offsetof(struct E2N_RICsubscriptionFailure_IEs__value, _asn_ctx),
4053         offsetof(struct E2N_RICsubscriptionFailure_IEs__value, present),
4054         sizeof(((struct E2N_RICsubscriptionFailure_IEs__value *)0)->present),
4055         asn_MAP_E2N_value_tag2el_36,
4056         4,      /* Count of tags in the map */
4057         asn_MAP_E2N_value_to_canonical_36,
4058         asn_MAP_E2N_value_from_canonical_36,
4059         -1      /* Extensions start */
4060 };
4061 static /* Use -fall-defs-global to expose */
4062 asn_TYPE_descriptor_t asn_DEF_E2N_value_36 = {
4063         "value",
4064         "value",
4065         &asn_OP_OPEN_TYPE,
4066         0,      /* No effective tags (pointer) */
4067         0,      /* No effective tags (count) */
4068         0,      /* No tags (pointer) */
4069         0,      /* No tags (count) */
4070         { 0, 0, OPEN_TYPE_constraint },
4071         asn_MBR_E2N_value_36,
4072         4,      /* Elements count */
4073         &asn_SPC_E2N_value_specs_36     /* Additional specs */
4074 };
4075
4076 asn_TYPE_member_t asn_MBR_E2N_RICsubscriptionFailure_IEs_33[] = {
4077         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs, id),
4078                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4079                 -1,     /* IMPLICIT tag at current level */
4080                 &asn_DEF_E2N_ProtocolIE_ID,
4081                 0,
4082                 { 0, &asn_PER_memb_E2N_id_constr_34,  memb_E2N_id_constraint_33 },
4083                 0, 0, /* No default value */
4084                 "id"
4085                 },
4086         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs, criticality),
4087                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4088                 -1,     /* IMPLICIT tag at current level */
4089                 &asn_DEF_E2N_Criticality,
4090                 select_RICsubscriptionFailure_IEs_E2N_criticality_type,
4091                 { 0, &asn_PER_memb_E2N_criticality_constr_35,  memb_E2N_criticality_constraint_33 },
4092                 0, 0, /* No default value */
4093                 "criticality"
4094                 },
4095         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionFailure_IEs, value),
4096                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4097                 +1,     /* EXPLICIT tag at current level */
4098                 &asn_DEF_E2N_value_36,
4099                 select_RICsubscriptionFailure_IEs_E2N_value_type,
4100                 { 0, &asn_PER_memb_E2N_value_constr_36,  memb_E2N_value_constraint_33 },
4101                 0, 0, /* No default value */
4102                 "value"
4103                 },
4104 };
4105 static const ber_tlv_tag_t asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33[] = {
4106         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4107 };
4108 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICsubscriptionFailure_IEs_tag2el_33[] = {
4109     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4110     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4111     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4112 };
4113 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICsubscriptionFailure_IEs_specs_33 = {
4114         sizeof(struct E2N_RICsubscriptionFailure_IEs),
4115         offsetof(struct E2N_RICsubscriptionFailure_IEs, _asn_ctx),
4116         asn_MAP_E2N_RICsubscriptionFailure_IEs_tag2el_33,
4117         3,      /* Count of tags in the map */
4118         0, 0, 0,        /* Optional elements (not needed) */
4119         -1,     /* First extension addition */
4120 };
4121 asn_TYPE_descriptor_t asn_DEF_E2N_RICsubscriptionFailure_IEs = {
4122         "RICsubscriptionFailure-IEs",
4123         "RICsubscriptionFailure-IEs",
4124         &asn_OP_SEQUENCE,
4125         asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33,
4126         sizeof(asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33)
4127                 /sizeof(asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
4128         asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33, /* Same as above */
4129         sizeof(asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33)
4130                 /sizeof(asn_DEF_E2N_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
4131         { 0, 0, SEQUENCE_constraint },
4132         asn_MBR_E2N_RICsubscriptionFailure_IEs_33,
4133         3,      /* Elements count */
4134         &asn_SPC_E2N_RICsubscriptionFailure_IEs_specs_33        /* Additional specs */
4135 };
4136
4137 static asn_TYPE_member_t asn_MBR_E2N_value_40[] = {
4138         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs__value, choice.RICrequestID),
4139                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4140                 0,
4141                 &asn_DEF_E2N_RICrequestID,
4142                 0,
4143                 { 0, 0, 0 },
4144                 0, 0, /* No default value */
4145                 "RICrequestID"
4146                 },
4147         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs__value, choice.RANfunctionID),
4148                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4149                 0,
4150                 &asn_DEF_E2N_RANfunctionID,
4151                 0,
4152                 { 0, 0, 0 },
4153                 0, 0, /* No default value */
4154                 "RANfunctionID"
4155                 },
4156 };
4157 static const unsigned asn_MAP_E2N_value_to_canonical_40[] = { 1, 0 };
4158 static const unsigned asn_MAP_E2N_value_from_canonical_40[] = { 1, 0 };
4159 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_40[] = {
4160     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4161     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
4162 };
4163 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_40 = {
4164         sizeof(struct E2N_RICsubscriptionDeleteRequest_IEs__value),
4165         offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs__value, _asn_ctx),
4166         offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs__value, present),
4167         sizeof(((struct E2N_RICsubscriptionDeleteRequest_IEs__value *)0)->present),
4168         asn_MAP_E2N_value_tag2el_40,
4169         2,      /* Count of tags in the map */
4170         asn_MAP_E2N_value_to_canonical_40,
4171         asn_MAP_E2N_value_from_canonical_40,
4172         -1      /* Extensions start */
4173 };
4174 static /* Use -fall-defs-global to expose */
4175 asn_TYPE_descriptor_t asn_DEF_E2N_value_40 = {
4176         "value",
4177         "value",
4178         &asn_OP_OPEN_TYPE,
4179         0,      /* No effective tags (pointer) */
4180         0,      /* No effective tags (count) */
4181         0,      /* No tags (pointer) */
4182         0,      /* No tags (count) */
4183         { 0, 0, OPEN_TYPE_constraint },
4184         asn_MBR_E2N_value_40,
4185         2,      /* Elements count */
4186         &asn_SPC_E2N_value_specs_40     /* Additional specs */
4187 };
4188
4189 asn_TYPE_member_t asn_MBR_E2N_RICsubscriptionDeleteRequest_IEs_37[] = {
4190         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs, id),
4191                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4192                 -1,     /* IMPLICIT tag at current level */
4193                 &asn_DEF_E2N_ProtocolIE_ID,
4194                 0,
4195                 { 0, &asn_PER_memb_E2N_id_constr_38,  memb_E2N_id_constraint_37 },
4196                 0, 0, /* No default value */
4197                 "id"
4198                 },
4199         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs, criticality),
4200                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4201                 -1,     /* IMPLICIT tag at current level */
4202                 &asn_DEF_E2N_Criticality,
4203                 select_RICsubscriptionDeleteRequest_IEs_E2N_criticality_type,
4204                 { 0, &asn_PER_memb_E2N_criticality_constr_39,  memb_E2N_criticality_constraint_37 },
4205                 0, 0, /* No default value */
4206                 "criticality"
4207                 },
4208         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs, value),
4209                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4210                 +1,     /* EXPLICIT tag at current level */
4211                 &asn_DEF_E2N_value_40,
4212                 select_RICsubscriptionDeleteRequest_IEs_E2N_value_type,
4213                 { 0, &asn_PER_memb_E2N_value_constr_40,  memb_E2N_value_constraint_37 },
4214                 0, 0, /* No default value */
4215                 "value"
4216                 },
4217 };
4218 static const ber_tlv_tag_t asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37[] = {
4219         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4220 };
4221 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICsubscriptionDeleteRequest_IEs_tag2el_37[] = {
4222     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4223     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4224     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4225 };
4226 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICsubscriptionDeleteRequest_IEs_specs_37 = {
4227         sizeof(struct E2N_RICsubscriptionDeleteRequest_IEs),
4228         offsetof(struct E2N_RICsubscriptionDeleteRequest_IEs, _asn_ctx),
4229         asn_MAP_E2N_RICsubscriptionDeleteRequest_IEs_tag2el_37,
4230         3,      /* Count of tags in the map */
4231         0, 0, 0,        /* Optional elements (not needed) */
4232         -1,     /* First extension addition */
4233 };
4234 asn_TYPE_descriptor_t asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs = {
4235         "RICsubscriptionDeleteRequest-IEs",
4236         "RICsubscriptionDeleteRequest-IEs",
4237         &asn_OP_SEQUENCE,
4238         asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37,
4239         sizeof(asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37)
4240                 /sizeof(asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
4241         asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37,   /* Same as above */
4242         sizeof(asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37)
4243                 /sizeof(asn_DEF_E2N_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
4244         { 0, 0, SEQUENCE_constraint },
4245         asn_MBR_E2N_RICsubscriptionDeleteRequest_IEs_37,
4246         3,      /* Elements count */
4247         &asn_SPC_E2N_RICsubscriptionDeleteRequest_IEs_specs_37  /* Additional specs */
4248 };
4249
4250 static asn_TYPE_member_t asn_MBR_E2N_value_44[] = {
4251         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs__value, choice.RICrequestID),
4252                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4253                 0,
4254                 &asn_DEF_E2N_RICrequestID,
4255                 0,
4256                 { 0, 0, 0 },
4257                 0, 0, /* No default value */
4258                 "RICrequestID"
4259                 },
4260         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs__value, choice.RANfunctionID),
4261                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4262                 0,
4263                 &asn_DEF_E2N_RANfunctionID,
4264                 0,
4265                 { 0, 0, 0 },
4266                 0, 0, /* No default value */
4267                 "RANfunctionID"
4268                 },
4269 };
4270 static const unsigned asn_MAP_E2N_value_to_canonical_44[] = { 1, 0 };
4271 static const unsigned asn_MAP_E2N_value_from_canonical_44[] = { 1, 0 };
4272 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_44[] = {
4273     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4274     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
4275 };
4276 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_44 = {
4277         sizeof(struct E2N_RICsubscriptionDeleteResponse_IEs__value),
4278         offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs__value, _asn_ctx),
4279         offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs__value, present),
4280         sizeof(((struct E2N_RICsubscriptionDeleteResponse_IEs__value *)0)->present),
4281         asn_MAP_E2N_value_tag2el_44,
4282         2,      /* Count of tags in the map */
4283         asn_MAP_E2N_value_to_canonical_44,
4284         asn_MAP_E2N_value_from_canonical_44,
4285         -1      /* Extensions start */
4286 };
4287 static /* Use -fall-defs-global to expose */
4288 asn_TYPE_descriptor_t asn_DEF_E2N_value_44 = {
4289         "value",
4290         "value",
4291         &asn_OP_OPEN_TYPE,
4292         0,      /* No effective tags (pointer) */
4293         0,      /* No effective tags (count) */
4294         0,      /* No tags (pointer) */
4295         0,      /* No tags (count) */
4296         { 0, 0, OPEN_TYPE_constraint },
4297         asn_MBR_E2N_value_44,
4298         2,      /* Elements count */
4299         &asn_SPC_E2N_value_specs_44     /* Additional specs */
4300 };
4301
4302 asn_TYPE_member_t asn_MBR_E2N_RICsubscriptionDeleteResponse_IEs_41[] = {
4303         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs, id),
4304                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4305                 -1,     /* IMPLICIT tag at current level */
4306                 &asn_DEF_E2N_ProtocolIE_ID,
4307                 0,
4308                 { 0, &asn_PER_memb_E2N_id_constr_42,  memb_E2N_id_constraint_41 },
4309                 0, 0, /* No default value */
4310                 "id"
4311                 },
4312         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs, criticality),
4313                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4314                 -1,     /* IMPLICIT tag at current level */
4315                 &asn_DEF_E2N_Criticality,
4316                 select_RICsubscriptionDeleteResponse_IEs_E2N_criticality_type,
4317                 { 0, &asn_PER_memb_E2N_criticality_constr_43,  memb_E2N_criticality_constraint_41 },
4318                 0, 0, /* No default value */
4319                 "criticality"
4320                 },
4321         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs, value),
4322                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4323                 +1,     /* EXPLICIT tag at current level */
4324                 &asn_DEF_E2N_value_44,
4325                 select_RICsubscriptionDeleteResponse_IEs_E2N_value_type,
4326                 { 0, &asn_PER_memb_E2N_value_constr_44,  memb_E2N_value_constraint_41 },
4327                 0, 0, /* No default value */
4328                 "value"
4329                 },
4330 };
4331 static const ber_tlv_tag_t asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41[] = {
4332         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4333 };
4334 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICsubscriptionDeleteResponse_IEs_tag2el_41[] = {
4335     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4336     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4337     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4338 };
4339 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICsubscriptionDeleteResponse_IEs_specs_41 = {
4340         sizeof(struct E2N_RICsubscriptionDeleteResponse_IEs),
4341         offsetof(struct E2N_RICsubscriptionDeleteResponse_IEs, _asn_ctx),
4342         asn_MAP_E2N_RICsubscriptionDeleteResponse_IEs_tag2el_41,
4343         3,      /* Count of tags in the map */
4344         0, 0, 0,        /* Optional elements (not needed) */
4345         -1,     /* First extension addition */
4346 };
4347 asn_TYPE_descriptor_t asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs = {
4348         "RICsubscriptionDeleteResponse-IEs",
4349         "RICsubscriptionDeleteResponse-IEs",
4350         &asn_OP_SEQUENCE,
4351         asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41,
4352         sizeof(asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41)
4353                 /sizeof(asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
4354         asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41,  /* Same as above */
4355         sizeof(asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41)
4356                 /sizeof(asn_DEF_E2N_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
4357         { 0, 0, SEQUENCE_constraint },
4358         asn_MBR_E2N_RICsubscriptionDeleteResponse_IEs_41,
4359         3,      /* Elements count */
4360         &asn_SPC_E2N_RICsubscriptionDeleteResponse_IEs_specs_41 /* Additional specs */
4361 };
4362
4363 static asn_TYPE_member_t asn_MBR_E2N_value_48[] = {
4364         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs__value, choice.RICrequestID),
4365                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4366                 0,
4367                 &asn_DEF_E2N_RICrequestID,
4368                 0,
4369                 { 0, 0, 0 },
4370                 0, 0, /* No default value */
4371                 "RICrequestID"
4372                 },
4373         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs__value, choice.RANfunctionID),
4374                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4375                 0,
4376                 &asn_DEF_E2N_RANfunctionID,
4377                 0,
4378                 { 0, 0, 0 },
4379                 0, 0, /* No default value */
4380                 "RANfunctionID"
4381                 },
4382         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs__value, choice.RICcause),
4383                 -1 /* Ambiguous tag (CHOICE?) */,
4384                 0,
4385                 &asn_DEF_E2N_RICcause,
4386                 0,
4387                 { 0, 0, 0 },
4388                 0, 0, /* No default value */
4389                 "RICcause"
4390                 },
4391         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs__value, choice.CriticalityDiagnostics),
4392                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4393                 0,
4394                 &asn_DEF_E2N_CriticalityDiagnostics,
4395                 0,
4396                 { 0, 0, 0 },
4397                 0, 0, /* No default value */
4398                 "CriticalityDiagnostics"
4399                 },
4400 };
4401 static const unsigned asn_MAP_E2N_value_to_canonical_48[] = { 1, 0, 3, 2 };
4402 static const unsigned asn_MAP_E2N_value_from_canonical_48[] = { 1, 0, 3, 2 };
4403 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_48[] = {
4404     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4405     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
4406     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
4407     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* radioNetwork */
4408     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* transport */
4409     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* protocol */
4410     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* misc */
4411     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* ric */
4412 };
4413 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_48 = {
4414         sizeof(struct E2N_RICsubscriptionDeleteFailure_IEs__value),
4415         offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs__value, _asn_ctx),
4416         offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs__value, present),
4417         sizeof(((struct E2N_RICsubscriptionDeleteFailure_IEs__value *)0)->present),
4418         asn_MAP_E2N_value_tag2el_48,
4419         8,      /* Count of tags in the map */
4420         asn_MAP_E2N_value_to_canonical_48,
4421         asn_MAP_E2N_value_from_canonical_48,
4422         -1      /* Extensions start */
4423 };
4424 static /* Use -fall-defs-global to expose */
4425 asn_TYPE_descriptor_t asn_DEF_E2N_value_48 = {
4426         "value",
4427         "value",
4428         &asn_OP_OPEN_TYPE,
4429         0,      /* No effective tags (pointer) */
4430         0,      /* No effective tags (count) */
4431         0,      /* No tags (pointer) */
4432         0,      /* No tags (count) */
4433         { 0, 0, OPEN_TYPE_constraint },
4434         asn_MBR_E2N_value_48,
4435         4,      /* Elements count */
4436         &asn_SPC_E2N_value_specs_48     /* Additional specs */
4437 };
4438
4439 asn_TYPE_member_t asn_MBR_E2N_RICsubscriptionDeleteFailure_IEs_45[] = {
4440         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs, id),
4441                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4442                 -1,     /* IMPLICIT tag at current level */
4443                 &asn_DEF_E2N_ProtocolIE_ID,
4444                 0,
4445                 { 0, &asn_PER_memb_E2N_id_constr_46,  memb_E2N_id_constraint_45 },
4446                 0, 0, /* No default value */
4447                 "id"
4448                 },
4449         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs, criticality),
4450                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4451                 -1,     /* IMPLICIT tag at current level */
4452                 &asn_DEF_E2N_Criticality,
4453                 select_RICsubscriptionDeleteFailure_IEs_E2N_criticality_type,
4454                 { 0, &asn_PER_memb_E2N_criticality_constr_47,  memb_E2N_criticality_constraint_45 },
4455                 0, 0, /* No default value */
4456                 "criticality"
4457                 },
4458         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs, value),
4459                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4460                 +1,     /* EXPLICIT tag at current level */
4461                 &asn_DEF_E2N_value_48,
4462                 select_RICsubscriptionDeleteFailure_IEs_E2N_value_type,
4463                 { 0, &asn_PER_memb_E2N_value_constr_48,  memb_E2N_value_constraint_45 },
4464                 0, 0, /* No default value */
4465                 "value"
4466                 },
4467 };
4468 static const ber_tlv_tag_t asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45[] = {
4469         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4470 };
4471 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICsubscriptionDeleteFailure_IEs_tag2el_45[] = {
4472     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4473     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4474     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4475 };
4476 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICsubscriptionDeleteFailure_IEs_specs_45 = {
4477         sizeof(struct E2N_RICsubscriptionDeleteFailure_IEs),
4478         offsetof(struct E2N_RICsubscriptionDeleteFailure_IEs, _asn_ctx),
4479         asn_MAP_E2N_RICsubscriptionDeleteFailure_IEs_tag2el_45,
4480         3,      /* Count of tags in the map */
4481         0, 0, 0,        /* Optional elements (not needed) */
4482         -1,     /* First extension addition */
4483 };
4484 asn_TYPE_descriptor_t asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs = {
4485         "RICsubscriptionDeleteFailure-IEs",
4486         "RICsubscriptionDeleteFailure-IEs",
4487         &asn_OP_SEQUENCE,
4488         asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45,
4489         sizeof(asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45)
4490                 /sizeof(asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
4491         asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45,   /* Same as above */
4492         sizeof(asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45)
4493                 /sizeof(asn_DEF_E2N_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
4494         { 0, 0, SEQUENCE_constraint },
4495         asn_MBR_E2N_RICsubscriptionDeleteFailure_IEs_45,
4496         3,      /* Elements count */
4497         &asn_SPC_E2N_RICsubscriptionDeleteFailure_IEs_specs_45  /* Additional specs */
4498 };
4499
4500 static asn_TYPE_member_t asn_MBR_E2N_value_52[] = {
4501         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICrequestID),
4502                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4503                 0,
4504                 &asn_DEF_E2N_RICrequestID,
4505                 0,
4506                 { 0, 0, 0 },
4507                 0, 0, /* No default value */
4508                 "RICrequestID"
4509                 },
4510         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RANfunctionID),
4511                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4512                 0,
4513                 &asn_DEF_E2N_RANfunctionID,
4514                 0,
4515                 { 0, 0, 0 },
4516                 0, 0, /* No default value */
4517                 "RANfunctionID"
4518                 },
4519         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICactionID),
4520                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4521                 0,
4522                 &asn_DEF_E2N_RICactionID,
4523                 0,
4524                 { 0, 0, 0 },
4525                 0, 0, /* No default value */
4526                 "RICactionID"
4527                 },
4528         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICindicationSN),
4529                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4530                 0,
4531                 &asn_DEF_E2N_RICindicationSN,
4532                 0,
4533                 { 0, 0, 0 },
4534                 0, 0, /* No default value */
4535                 "RICindicationSN"
4536                 },
4537         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICindicationType),
4538                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4539                 0,
4540                 &asn_DEF_E2N_RICindicationType,
4541                 0,
4542                 { 0, 0, 0 },
4543                 0, 0, /* No default value */
4544                 "RICindicationType"
4545                 },
4546         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICindicationHeader),
4547                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4548                 0,
4549                 &asn_DEF_E2N_RICindicationHeader,
4550                 0,
4551                 { 0, 0, 0 },
4552                 0, 0, /* No default value */
4553                 "RICindicationHeader"
4554                 },
4555         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICindicationMessage),
4556                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4557                 0,
4558                 &asn_DEF_E2N_RICindicationMessage,
4559                 0,
4560                 { 0, 0, 0 },
4561                 0, 0, /* No default value */
4562                 "RICindicationMessage"
4563                 },
4564         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs__value, choice.RICcallProcessID),
4565                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4566                 0,
4567                 &asn_DEF_E2N_RICcallProcessID,
4568                 0,
4569                 { 0, 0, 0 },
4570                 0, 0, /* No default value */
4571                 "RICcallProcessID"
4572                 },
4573 };
4574 static const unsigned asn_MAP_E2N_value_to_canonical_52[] = { 1, 2, 3, 5, 6, 7, 4, 0 };
4575 static const unsigned asn_MAP_E2N_value_from_canonical_52[] = { 7, 0, 1, 2, 6, 3, 4, 5 };
4576 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_52[] = {
4577     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 2 }, /* RANfunctionID */
4578     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* RICactionID */
4579     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 0 }, /* RICindicationSN */
4580     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 5, 0, 2 }, /* RICindicationHeader */
4581     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 6, -1, 1 }, /* RICindicationMessage */
4582     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 7, -2, 0 }, /* RICcallProcessID */
4583     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* RICindicationType */
4584     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
4585 };
4586 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_52 = {
4587         sizeof(struct E2N_RICindication_IEs__value),
4588         offsetof(struct E2N_RICindication_IEs__value, _asn_ctx),
4589         offsetof(struct E2N_RICindication_IEs__value, present),
4590         sizeof(((struct E2N_RICindication_IEs__value *)0)->present),
4591         asn_MAP_E2N_value_tag2el_52,
4592         8,      /* Count of tags in the map */
4593         asn_MAP_E2N_value_to_canonical_52,
4594         asn_MAP_E2N_value_from_canonical_52,
4595         -1      /* Extensions start */
4596 };
4597 static /* Use -fall-defs-global to expose */
4598 asn_TYPE_descriptor_t asn_DEF_E2N_value_52 = {
4599         "value",
4600         "value",
4601         &asn_OP_OPEN_TYPE,
4602         0,      /* No effective tags (pointer) */
4603         0,      /* No effective tags (count) */
4604         0,      /* No tags (pointer) */
4605         0,      /* No tags (count) */
4606         { 0, 0, OPEN_TYPE_constraint },
4607         asn_MBR_E2N_value_52,
4608         8,      /* Elements count */
4609         &asn_SPC_E2N_value_specs_52     /* Additional specs */
4610 };
4611
4612 asn_TYPE_member_t asn_MBR_E2N_RICindication_IEs_49[] = {
4613         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs, id),
4614                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4615                 -1,     /* IMPLICIT tag at current level */
4616                 &asn_DEF_E2N_ProtocolIE_ID,
4617                 0,
4618                 { 0, &asn_PER_memb_E2N_id_constr_50,  memb_E2N_id_constraint_49 },
4619                 0, 0, /* No default value */
4620                 "id"
4621                 },
4622         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs, criticality),
4623                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4624                 -1,     /* IMPLICIT tag at current level */
4625                 &asn_DEF_E2N_Criticality,
4626                 select_RICindication_IEs_E2N_criticality_type,
4627                 { 0, &asn_PER_memb_E2N_criticality_constr_51,  memb_E2N_criticality_constraint_49 },
4628                 0, 0, /* No default value */
4629                 "criticality"
4630                 },
4631         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICindication_IEs, value),
4632                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4633                 +1,     /* EXPLICIT tag at current level */
4634                 &asn_DEF_E2N_value_52,
4635                 select_RICindication_IEs_E2N_value_type,
4636                 { 0, &asn_PER_memb_E2N_value_constr_52,  memb_E2N_value_constraint_49 },
4637                 0, 0, /* No default value */
4638                 "value"
4639                 },
4640 };
4641 static const ber_tlv_tag_t asn_DEF_E2N_RICindication_IEs_tags_49[] = {
4642         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4643 };
4644 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICindication_IEs_tag2el_49[] = {
4645     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4646     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4647     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4648 };
4649 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICindication_IEs_specs_49 = {
4650         sizeof(struct E2N_RICindication_IEs),
4651         offsetof(struct E2N_RICindication_IEs, _asn_ctx),
4652         asn_MAP_E2N_RICindication_IEs_tag2el_49,
4653         3,      /* Count of tags in the map */
4654         0, 0, 0,        /* Optional elements (not needed) */
4655         -1,     /* First extension addition */
4656 };
4657 asn_TYPE_descriptor_t asn_DEF_E2N_RICindication_IEs = {
4658         "RICindication-IEs",
4659         "RICindication-IEs",
4660         &asn_OP_SEQUENCE,
4661         asn_DEF_E2N_RICindication_IEs_tags_49,
4662         sizeof(asn_DEF_E2N_RICindication_IEs_tags_49)
4663                 /sizeof(asn_DEF_E2N_RICindication_IEs_tags_49[0]), /* 1 */
4664         asn_DEF_E2N_RICindication_IEs_tags_49,  /* Same as above */
4665         sizeof(asn_DEF_E2N_RICindication_IEs_tags_49)
4666                 /sizeof(asn_DEF_E2N_RICindication_IEs_tags_49[0]), /* 1 */
4667         { 0, 0, SEQUENCE_constraint },
4668         asn_MBR_E2N_RICindication_IEs_49,
4669         3,      /* Elements count */
4670         &asn_SPC_E2N_RICindication_IEs_specs_49 /* Additional specs */
4671 };
4672
4673 static asn_TYPE_member_t asn_MBR_E2N_value_56[] = {
4674         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs__value, choice.RICrequestID),
4675                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4676                 0,
4677                 &asn_DEF_E2N_RICrequestID,
4678                 0,
4679                 { 0, 0, 0 },
4680                 0, 0, /* No default value */
4681                 "RICrequestID"
4682                 },
4683         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs__value, choice.RANfunctionID),
4684                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4685                 0,
4686                 &asn_DEF_E2N_RANfunctionID,
4687                 0,
4688                 { 0, 0, 0 },
4689                 0, 0, /* No default value */
4690                 "RANfunctionID"
4691                 },
4692         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs__value, choice.RICcallProcessID),
4693                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4694                 0,
4695                 &asn_DEF_E2N_RICcallProcessID,
4696                 0,
4697                 { 0, 0, 0 },
4698                 0, 0, /* No default value */
4699                 "RICcallProcessID"
4700                 },
4701         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs__value, choice.RICcontrolHeader),
4702                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4703                 0,
4704                 &asn_DEF_E2N_RICcontrolHeader,
4705                 0,
4706                 { 0, 0, 0 },
4707                 0, 0, /* No default value */
4708                 "RICcontrolHeader"
4709                 },
4710         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs__value, choice.RICcontrolMessage),
4711                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4712                 0,
4713                 &asn_DEF_E2N_RICcontrolMessage,
4714                 0,
4715                 { 0, 0, 0 },
4716                 0, 0, /* No default value */
4717                 "RICcontrolMessage"
4718                 },
4719         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs__value, choice.RICcontrolAckRequest),
4720                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4721                 0,
4722                 &asn_DEF_E2N_RICcontrolAckRequest,
4723                 0,
4724                 { 0, 0, 0 },
4725                 0, 0, /* No default value */
4726                 "RICcontrolAckRequest"
4727                 },
4728 };
4729 static const unsigned asn_MAP_E2N_value_to_canonical_56[] = { 1, 2, 3, 4, 5, 0 };
4730 static const unsigned asn_MAP_E2N_value_from_canonical_56[] = { 5, 0, 1, 2, 3, 4 };
4731 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_56[] = {
4732     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4733     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 2 }, /* RICcallProcessID */
4734     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 1 }, /* RICcontrolHeader */
4735     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -2, 0 }, /* RICcontrolMessage */
4736     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 5, 0, 0 }, /* RICcontrolAckRequest */
4737     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
4738 };
4739 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_56 = {
4740         sizeof(struct E2N_RICcontrolRequest_IEs__value),
4741         offsetof(struct E2N_RICcontrolRequest_IEs__value, _asn_ctx),
4742         offsetof(struct E2N_RICcontrolRequest_IEs__value, present),
4743         sizeof(((struct E2N_RICcontrolRequest_IEs__value *)0)->present),
4744         asn_MAP_E2N_value_tag2el_56,
4745         6,      /* Count of tags in the map */
4746         asn_MAP_E2N_value_to_canonical_56,
4747         asn_MAP_E2N_value_from_canonical_56,
4748         -1      /* Extensions start */
4749 };
4750 static /* Use -fall-defs-global to expose */
4751 asn_TYPE_descriptor_t asn_DEF_E2N_value_56 = {
4752         "value",
4753         "value",
4754         &asn_OP_OPEN_TYPE,
4755         0,      /* No effective tags (pointer) */
4756         0,      /* No effective tags (count) */
4757         0,      /* No tags (pointer) */
4758         0,      /* No tags (count) */
4759         { 0, 0, OPEN_TYPE_constraint },
4760         asn_MBR_E2N_value_56,
4761         6,      /* Elements count */
4762         &asn_SPC_E2N_value_specs_56     /* Additional specs */
4763 };
4764
4765 asn_TYPE_member_t asn_MBR_E2N_RICcontrolRequest_IEs_53[] = {
4766         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs, id),
4767                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4768                 -1,     /* IMPLICIT tag at current level */
4769                 &asn_DEF_E2N_ProtocolIE_ID,
4770                 0,
4771                 { 0, &asn_PER_memb_E2N_id_constr_54,  memb_E2N_id_constraint_53 },
4772                 0, 0, /* No default value */
4773                 "id"
4774                 },
4775         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs, criticality),
4776                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4777                 -1,     /* IMPLICIT tag at current level */
4778                 &asn_DEF_E2N_Criticality,
4779                 select_RICcontrolRequest_IEs_E2N_criticality_type,
4780                 { 0, &asn_PER_memb_E2N_criticality_constr_55,  memb_E2N_criticality_constraint_53 },
4781                 0, 0, /* No default value */
4782                 "criticality"
4783                 },
4784         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolRequest_IEs, value),
4785                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4786                 +1,     /* EXPLICIT tag at current level */
4787                 &asn_DEF_E2N_value_56,
4788                 select_RICcontrolRequest_IEs_E2N_value_type,
4789                 { 0, &asn_PER_memb_E2N_value_constr_56,  memb_E2N_value_constraint_53 },
4790                 0, 0, /* No default value */
4791                 "value"
4792                 },
4793 };
4794 static const ber_tlv_tag_t asn_DEF_E2N_RICcontrolRequest_IEs_tags_53[] = {
4795         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4796 };
4797 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICcontrolRequest_IEs_tag2el_53[] = {
4798     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4799     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4800     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4801 };
4802 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICcontrolRequest_IEs_specs_53 = {
4803         sizeof(struct E2N_RICcontrolRequest_IEs),
4804         offsetof(struct E2N_RICcontrolRequest_IEs, _asn_ctx),
4805         asn_MAP_E2N_RICcontrolRequest_IEs_tag2el_53,
4806         3,      /* Count of tags in the map */
4807         0, 0, 0,        /* Optional elements (not needed) */
4808         -1,     /* First extension addition */
4809 };
4810 asn_TYPE_descriptor_t asn_DEF_E2N_RICcontrolRequest_IEs = {
4811         "RICcontrolRequest-IEs",
4812         "RICcontrolRequest-IEs",
4813         &asn_OP_SEQUENCE,
4814         asn_DEF_E2N_RICcontrolRequest_IEs_tags_53,
4815         sizeof(asn_DEF_E2N_RICcontrolRequest_IEs_tags_53)
4816                 /sizeof(asn_DEF_E2N_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
4817         asn_DEF_E2N_RICcontrolRequest_IEs_tags_53,      /* Same as above */
4818         sizeof(asn_DEF_E2N_RICcontrolRequest_IEs_tags_53)
4819                 /sizeof(asn_DEF_E2N_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
4820         { 0, 0, SEQUENCE_constraint },
4821         asn_MBR_E2N_RICcontrolRequest_IEs_53,
4822         3,      /* Elements count */
4823         &asn_SPC_E2N_RICcontrolRequest_IEs_specs_53     /* Additional specs */
4824 };
4825
4826 static asn_TYPE_member_t asn_MBR_E2N_value_60[] = {
4827         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs__value, choice.RICrequestID),
4828                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4829                 0,
4830                 &asn_DEF_E2N_RICrequestID,
4831                 0,
4832                 { 0, 0, 0 },
4833                 0, 0, /* No default value */
4834                 "RICrequestID"
4835                 },
4836         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs__value, choice.RANfunctionID),
4837                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4838                 0,
4839                 &asn_DEF_E2N_RANfunctionID,
4840                 0,
4841                 { 0, 0, 0 },
4842                 0, 0, /* No default value */
4843                 "RANfunctionID"
4844                 },
4845         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs__value, choice.RICcallProcessID),
4846                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4847                 0,
4848                 &asn_DEF_E2N_RICcallProcessID,
4849                 0,
4850                 { 0, 0, 0 },
4851                 0, 0, /* No default value */
4852                 "RICcallProcessID"
4853                 },
4854         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs__value, choice.RICcontrolStatus),
4855                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4856                 0,
4857                 &asn_DEF_E2N_RICcontrolStatus,
4858                 0,
4859                 { 0, 0, 0 },
4860                 0, 0, /* No default value */
4861                 "RICcontrolStatus"
4862                 },
4863 };
4864 static const unsigned asn_MAP_E2N_value_to_canonical_60[] = { 1, 2, 3, 0 };
4865 static const unsigned asn_MAP_E2N_value_from_canonical_60[] = { 3, 0, 1, 2 };
4866 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_60[] = {
4867     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4868     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 0 }, /* RICcallProcessID */
4869     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 3, 0, 0 }, /* RICcontrolStatus */
4870     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
4871 };
4872 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_60 = {
4873         sizeof(struct E2N_RICcontrolAcknowledge_IEs__value),
4874         offsetof(struct E2N_RICcontrolAcknowledge_IEs__value, _asn_ctx),
4875         offsetof(struct E2N_RICcontrolAcknowledge_IEs__value, present),
4876         sizeof(((struct E2N_RICcontrolAcknowledge_IEs__value *)0)->present),
4877         asn_MAP_E2N_value_tag2el_60,
4878         4,      /* Count of tags in the map */
4879         asn_MAP_E2N_value_to_canonical_60,
4880         asn_MAP_E2N_value_from_canonical_60,
4881         -1      /* Extensions start */
4882 };
4883 static /* Use -fall-defs-global to expose */
4884 asn_TYPE_descriptor_t asn_DEF_E2N_value_60 = {
4885         "value",
4886         "value",
4887         &asn_OP_OPEN_TYPE,
4888         0,      /* No effective tags (pointer) */
4889         0,      /* No effective tags (count) */
4890         0,      /* No tags (pointer) */
4891         0,      /* No tags (count) */
4892         { 0, 0, OPEN_TYPE_constraint },
4893         asn_MBR_E2N_value_60,
4894         4,      /* Elements count */
4895         &asn_SPC_E2N_value_specs_60     /* Additional specs */
4896 };
4897
4898 asn_TYPE_member_t asn_MBR_E2N_RICcontrolAcknowledge_IEs_57[] = {
4899         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs, id),
4900                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4901                 -1,     /* IMPLICIT tag at current level */
4902                 &asn_DEF_E2N_ProtocolIE_ID,
4903                 0,
4904                 { 0, &asn_PER_memb_E2N_id_constr_58,  memb_E2N_id_constraint_57 },
4905                 0, 0, /* No default value */
4906                 "id"
4907                 },
4908         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs, criticality),
4909                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4910                 -1,     /* IMPLICIT tag at current level */
4911                 &asn_DEF_E2N_Criticality,
4912                 select_RICcontrolAcknowledge_IEs_E2N_criticality_type,
4913                 { 0, &asn_PER_memb_E2N_criticality_constr_59,  memb_E2N_criticality_constraint_57 },
4914                 0, 0, /* No default value */
4915                 "criticality"
4916                 },
4917         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolAcknowledge_IEs, value),
4918                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4919                 +1,     /* EXPLICIT tag at current level */
4920                 &asn_DEF_E2N_value_60,
4921                 select_RICcontrolAcknowledge_IEs_E2N_value_type,
4922                 { 0, &asn_PER_memb_E2N_value_constr_60,  memb_E2N_value_constraint_57 },
4923                 0, 0, /* No default value */
4924                 "value"
4925                 },
4926 };
4927 static const ber_tlv_tag_t asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57[] = {
4928         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4929 };
4930 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICcontrolAcknowledge_IEs_tag2el_57[] = {
4931     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4932     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4933     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4934 };
4935 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICcontrolAcknowledge_IEs_specs_57 = {
4936         sizeof(struct E2N_RICcontrolAcknowledge_IEs),
4937         offsetof(struct E2N_RICcontrolAcknowledge_IEs, _asn_ctx),
4938         asn_MAP_E2N_RICcontrolAcknowledge_IEs_tag2el_57,
4939         3,      /* Count of tags in the map */
4940         0, 0, 0,        /* Optional elements (not needed) */
4941         -1,     /* First extension addition */
4942 };
4943 asn_TYPE_descriptor_t asn_DEF_E2N_RICcontrolAcknowledge_IEs = {
4944         "RICcontrolAcknowledge-IEs",
4945         "RICcontrolAcknowledge-IEs",
4946         &asn_OP_SEQUENCE,
4947         asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57,
4948         sizeof(asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57)
4949                 /sizeof(asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
4950         asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57,  /* Same as above */
4951         sizeof(asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57)
4952                 /sizeof(asn_DEF_E2N_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
4953         { 0, 0, SEQUENCE_constraint },
4954         asn_MBR_E2N_RICcontrolAcknowledge_IEs_57,
4955         3,      /* Elements count */
4956         &asn_SPC_E2N_RICcontrolAcknowledge_IEs_specs_57 /* Additional specs */
4957 };
4958
4959 static asn_TYPE_member_t asn_MBR_E2N_value_64[] = {
4960         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs__value, choice.RICrequestID),
4961                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4962                 0,
4963                 &asn_DEF_E2N_RICrequestID,
4964                 0,
4965                 { 0, 0, 0 },
4966                 0, 0, /* No default value */
4967                 "RICrequestID"
4968                 },
4969         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs__value, choice.RANfunctionID),
4970                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4971                 0,
4972                 &asn_DEF_E2N_RANfunctionID,
4973                 0,
4974                 { 0, 0, 0 },
4975                 0, 0, /* No default value */
4976                 "RANfunctionID"
4977                 },
4978         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs__value, choice.RICcallProcessID),
4979                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
4980                 0,
4981                 &asn_DEF_E2N_RICcallProcessID,
4982                 0,
4983                 { 0, 0, 0 },
4984                 0, 0, /* No default value */
4985                 "RICcallProcessID"
4986                 },
4987         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs__value, choice.RICcause),
4988                 -1 /* Ambiguous tag (CHOICE?) */,
4989                 0,
4990                 &asn_DEF_E2N_RICcause,
4991                 0,
4992                 { 0, 0, 0 },
4993                 0, 0, /* No default value */
4994                 "RICcause"
4995                 },
4996 };
4997 static const unsigned asn_MAP_E2N_value_to_canonical_64[] = { 1, 2, 0, 3 };
4998 static const unsigned asn_MAP_E2N_value_from_canonical_64[] = { 2, 0, 1, 3 };
4999 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_64[] = {
5000     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5001     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 0 }, /* RICcallProcessID */
5002     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* RICrequestID */
5003     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 3, 0, 0 }, /* radioNetwork */
5004     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* transport */
5005     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 3, 0, 0 }, /* protocol */
5006     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* misc */
5007     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* ric */
5008 };
5009 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_64 = {
5010         sizeof(struct E2N_RICcontrolFailure_IEs__value),
5011         offsetof(struct E2N_RICcontrolFailure_IEs__value, _asn_ctx),
5012         offsetof(struct E2N_RICcontrolFailure_IEs__value, present),
5013         sizeof(((struct E2N_RICcontrolFailure_IEs__value *)0)->present),
5014         asn_MAP_E2N_value_tag2el_64,
5015         8,      /* Count of tags in the map */
5016         asn_MAP_E2N_value_to_canonical_64,
5017         asn_MAP_E2N_value_from_canonical_64,
5018         -1      /* Extensions start */
5019 };
5020 static /* Use -fall-defs-global to expose */
5021 asn_TYPE_descriptor_t asn_DEF_E2N_value_64 = {
5022         "value",
5023         "value",
5024         &asn_OP_OPEN_TYPE,
5025         0,      /* No effective tags (pointer) */
5026         0,      /* No effective tags (count) */
5027         0,      /* No tags (pointer) */
5028         0,      /* No tags (count) */
5029         { 0, 0, OPEN_TYPE_constraint },
5030         asn_MBR_E2N_value_64,
5031         4,      /* Elements count */
5032         &asn_SPC_E2N_value_specs_64     /* Additional specs */
5033 };
5034
5035 asn_TYPE_member_t asn_MBR_E2N_RICcontrolFailure_IEs_61[] = {
5036         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs, id),
5037                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5038                 -1,     /* IMPLICIT tag at current level */
5039                 &asn_DEF_E2N_ProtocolIE_ID,
5040                 0,
5041                 { 0, &asn_PER_memb_E2N_id_constr_62,  memb_E2N_id_constraint_61 },
5042                 0, 0, /* No default value */
5043                 "id"
5044                 },
5045         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs, criticality),
5046                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5047                 -1,     /* IMPLICIT tag at current level */
5048                 &asn_DEF_E2N_Criticality,
5049                 select_RICcontrolFailure_IEs_E2N_criticality_type,
5050                 { 0, &asn_PER_memb_E2N_criticality_constr_63,  memb_E2N_criticality_constraint_61 },
5051                 0, 0, /* No default value */
5052                 "criticality"
5053                 },
5054         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICcontrolFailure_IEs, value),
5055                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5056                 +1,     /* EXPLICIT tag at current level */
5057                 &asn_DEF_E2N_value_64,
5058                 select_RICcontrolFailure_IEs_E2N_value_type,
5059                 { 0, &asn_PER_memb_E2N_value_constr_64,  memb_E2N_value_constraint_61 },
5060                 0, 0, /* No default value */
5061                 "value"
5062                 },
5063 };
5064 static const ber_tlv_tag_t asn_DEF_E2N_RICcontrolFailure_IEs_tags_61[] = {
5065         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5066 };
5067 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICcontrolFailure_IEs_tag2el_61[] = {
5068     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5069     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5070     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5071 };
5072 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICcontrolFailure_IEs_specs_61 = {
5073         sizeof(struct E2N_RICcontrolFailure_IEs),
5074         offsetof(struct E2N_RICcontrolFailure_IEs, _asn_ctx),
5075         asn_MAP_E2N_RICcontrolFailure_IEs_tag2el_61,
5076         3,      /* Count of tags in the map */
5077         0, 0, 0,        /* Optional elements (not needed) */
5078         -1,     /* First extension addition */
5079 };
5080 asn_TYPE_descriptor_t asn_DEF_E2N_RICcontrolFailure_IEs = {
5081         "RICcontrolFailure-IEs",
5082         "RICcontrolFailure-IEs",
5083         &asn_OP_SEQUENCE,
5084         asn_DEF_E2N_RICcontrolFailure_IEs_tags_61,
5085         sizeof(asn_DEF_E2N_RICcontrolFailure_IEs_tags_61)
5086                 /sizeof(asn_DEF_E2N_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
5087         asn_DEF_E2N_RICcontrolFailure_IEs_tags_61,      /* Same as above */
5088         sizeof(asn_DEF_E2N_RICcontrolFailure_IEs_tags_61)
5089                 /sizeof(asn_DEF_E2N_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
5090         { 0, 0, SEQUENCE_constraint },
5091         asn_MBR_E2N_RICcontrolFailure_IEs_61,
5092         3,      /* Elements count */
5093         &asn_SPC_E2N_RICcontrolFailure_IEs_specs_61     /* Additional specs */
5094 };
5095
5096 static asn_TYPE_member_t asn_MBR_E2N_value_68[] = {
5097         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdate_IEs__value, choice.RANfunctions_List),
5098                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5099                 0,
5100                 &asn_DEF_E2N_RANfunctions_List,
5101                 0,
5102                 { 0, 0, 0 },
5103                 0, 0, /* No default value */
5104                 "RANfunctions-List"
5105                 },
5106         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdate_IEs__value, choice.RANfunctionsID_List),
5107                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5108                 0,
5109                 &asn_DEF_E2N_RANfunctionsID_List,
5110                 0,
5111                 { 0, 0, 0 },
5112                 0, 0, /* No default value */
5113                 "RANfunctionsID-List"
5114                 },
5115 };
5116 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_68[] = {
5117     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctions-List */
5118     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsID-List */
5119 };
5120 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_68 = {
5121         sizeof(struct E2N_RICserviceUpdate_IEs__value),
5122         offsetof(struct E2N_RICserviceUpdate_IEs__value, _asn_ctx),
5123         offsetof(struct E2N_RICserviceUpdate_IEs__value, present),
5124         sizeof(((struct E2N_RICserviceUpdate_IEs__value *)0)->present),
5125         asn_MAP_E2N_value_tag2el_68,
5126         2,      /* Count of tags in the map */
5127         0, 0,
5128         -1      /* Extensions start */
5129 };
5130 static /* Use -fall-defs-global to expose */
5131 asn_TYPE_descriptor_t asn_DEF_E2N_value_68 = {
5132         "value",
5133         "value",
5134         &asn_OP_OPEN_TYPE,
5135         0,      /* No effective tags (pointer) */
5136         0,      /* No effective tags (count) */
5137         0,      /* No tags (pointer) */
5138         0,      /* No tags (count) */
5139         { 0, 0, OPEN_TYPE_constraint },
5140         asn_MBR_E2N_value_68,
5141         2,      /* Elements count */
5142         &asn_SPC_E2N_value_specs_68     /* Additional specs */
5143 };
5144
5145 asn_TYPE_member_t asn_MBR_E2N_RICserviceUpdate_IEs_65[] = {
5146         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdate_IEs, id),
5147                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5148                 -1,     /* IMPLICIT tag at current level */
5149                 &asn_DEF_E2N_ProtocolIE_ID,
5150                 0,
5151                 { 0, &asn_PER_memb_E2N_id_constr_66,  memb_E2N_id_constraint_65 },
5152                 0, 0, /* No default value */
5153                 "id"
5154                 },
5155         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdate_IEs, criticality),
5156                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5157                 -1,     /* IMPLICIT tag at current level */
5158                 &asn_DEF_E2N_Criticality,
5159                 select_RICserviceUpdate_IEs_E2N_criticality_type,
5160                 { 0, &asn_PER_memb_E2N_criticality_constr_67,  memb_E2N_criticality_constraint_65 },
5161                 0, 0, /* No default value */
5162                 "criticality"
5163                 },
5164         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdate_IEs, value),
5165                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5166                 +1,     /* EXPLICIT tag at current level */
5167                 &asn_DEF_E2N_value_68,
5168                 select_RICserviceUpdate_IEs_E2N_value_type,
5169                 { 0, &asn_PER_memb_E2N_value_constr_68,  memb_E2N_value_constraint_65 },
5170                 0, 0, /* No default value */
5171                 "value"
5172                 },
5173 };
5174 static const ber_tlv_tag_t asn_DEF_E2N_RICserviceUpdate_IEs_tags_65[] = {
5175         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5176 };
5177 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICserviceUpdate_IEs_tag2el_65[] = {
5178     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5179     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5180     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5181 };
5182 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICserviceUpdate_IEs_specs_65 = {
5183         sizeof(struct E2N_RICserviceUpdate_IEs),
5184         offsetof(struct E2N_RICserviceUpdate_IEs, _asn_ctx),
5185         asn_MAP_E2N_RICserviceUpdate_IEs_tag2el_65,
5186         3,      /* Count of tags in the map */
5187         0, 0, 0,        /* Optional elements (not needed) */
5188         -1,     /* First extension addition */
5189 };
5190 asn_TYPE_descriptor_t asn_DEF_E2N_RICserviceUpdate_IEs = {
5191         "RICserviceUpdate-IEs",
5192         "RICserviceUpdate-IEs",
5193         &asn_OP_SEQUENCE,
5194         asn_DEF_E2N_RICserviceUpdate_IEs_tags_65,
5195         sizeof(asn_DEF_E2N_RICserviceUpdate_IEs_tags_65)
5196                 /sizeof(asn_DEF_E2N_RICserviceUpdate_IEs_tags_65[0]), /* 1 */
5197         asn_DEF_E2N_RICserviceUpdate_IEs_tags_65,       /* Same as above */
5198         sizeof(asn_DEF_E2N_RICserviceUpdate_IEs_tags_65)
5199                 /sizeof(asn_DEF_E2N_RICserviceUpdate_IEs_tags_65[0]), /* 1 */
5200         { 0, 0, SEQUENCE_constraint },
5201         asn_MBR_E2N_RICserviceUpdate_IEs_65,
5202         3,      /* Elements count */
5203         &asn_SPC_E2N_RICserviceUpdate_IEs_specs_65      /* Additional specs */
5204 };
5205
5206 static asn_TYPE_member_t asn_MBR_E2N_value_72[] = {
5207         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsID_List),
5208                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5209                 0,
5210                 &asn_DEF_E2N_RANfunctionsID_List,
5211                 0,
5212                 { 0, 0, 0 },
5213                 0, 0, /* No default value */
5214                 "RANfunctionsID-List"
5215                 },
5216         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsIDcause_List),
5217                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5218                 0,
5219                 &asn_DEF_E2N_RANfunctionsIDcause_List,
5220                 0,
5221                 { 0, 0, 0 },
5222                 0, 0, /* No default value */
5223                 "RANfunctionsIDcause-List"
5224                 },
5225 };
5226 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_72[] = {
5227     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsID-List */
5228     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsIDcause-List */
5229 };
5230 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_72 = {
5231         sizeof(struct E2N_RICserviceUpdateAcknowledge_IEs__value),
5232         offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs__value, _asn_ctx),
5233         offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs__value, present),
5234         sizeof(((struct E2N_RICserviceUpdateAcknowledge_IEs__value *)0)->present),
5235         asn_MAP_E2N_value_tag2el_72,
5236         2,      /* Count of tags in the map */
5237         0, 0,
5238         -1      /* Extensions start */
5239 };
5240 static /* Use -fall-defs-global to expose */
5241 asn_TYPE_descriptor_t asn_DEF_E2N_value_72 = {
5242         "value",
5243         "value",
5244         &asn_OP_OPEN_TYPE,
5245         0,      /* No effective tags (pointer) */
5246         0,      /* No effective tags (count) */
5247         0,      /* No tags (pointer) */
5248         0,      /* No tags (count) */
5249         { 0, 0, OPEN_TYPE_constraint },
5250         asn_MBR_E2N_value_72,
5251         2,      /* Elements count */
5252         &asn_SPC_E2N_value_specs_72     /* Additional specs */
5253 };
5254
5255 asn_TYPE_member_t asn_MBR_E2N_RICserviceUpdateAcknowledge_IEs_69[] = {
5256         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs, id),
5257                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5258                 -1,     /* IMPLICIT tag at current level */
5259                 &asn_DEF_E2N_ProtocolIE_ID,
5260                 0,
5261                 { 0, &asn_PER_memb_E2N_id_constr_70,  memb_E2N_id_constraint_69 },
5262                 0, 0, /* No default value */
5263                 "id"
5264                 },
5265         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs, criticality),
5266                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5267                 -1,     /* IMPLICIT tag at current level */
5268                 &asn_DEF_E2N_Criticality,
5269                 select_RICserviceUpdateAcknowledge_IEs_E2N_criticality_type,
5270                 { 0, &asn_PER_memb_E2N_criticality_constr_71,  memb_E2N_criticality_constraint_69 },
5271                 0, 0, /* No default value */
5272                 "criticality"
5273                 },
5274         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs, value),
5275                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5276                 +1,     /* EXPLICIT tag at current level */
5277                 &asn_DEF_E2N_value_72,
5278                 select_RICserviceUpdateAcknowledge_IEs_E2N_value_type,
5279                 { 0, &asn_PER_memb_E2N_value_constr_72,  memb_E2N_value_constraint_69 },
5280                 0, 0, /* No default value */
5281                 "value"
5282                 },
5283 };
5284 static const ber_tlv_tag_t asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69[] = {
5285         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5286 };
5287 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICserviceUpdateAcknowledge_IEs_tag2el_69[] = {
5288     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5289     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5290     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5291 };
5292 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICserviceUpdateAcknowledge_IEs_specs_69 = {
5293         sizeof(struct E2N_RICserviceUpdateAcknowledge_IEs),
5294         offsetof(struct E2N_RICserviceUpdateAcknowledge_IEs, _asn_ctx),
5295         asn_MAP_E2N_RICserviceUpdateAcknowledge_IEs_tag2el_69,
5296         3,      /* Count of tags in the map */
5297         0, 0, 0,        /* Optional elements (not needed) */
5298         -1,     /* First extension addition */
5299 };
5300 asn_TYPE_descriptor_t asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs = {
5301         "RICserviceUpdateAcknowledge-IEs",
5302         "RICserviceUpdateAcknowledge-IEs",
5303         &asn_OP_SEQUENCE,
5304         asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69,
5305         sizeof(asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69)
5306                 /sizeof(asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69[0]), /* 1 */
5307         asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69,    /* Same as above */
5308         sizeof(asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69)
5309                 /sizeof(asn_DEF_E2N_RICserviceUpdateAcknowledge_IEs_tags_69[0]), /* 1 */
5310         { 0, 0, SEQUENCE_constraint },
5311         asn_MBR_E2N_RICserviceUpdateAcknowledge_IEs_69,
5312         3,      /* Elements count */
5313         &asn_SPC_E2N_RICserviceUpdateAcknowledge_IEs_specs_69   /* Additional specs */
5314 };
5315
5316 static asn_TYPE_member_t asn_MBR_E2N_value_76[] = {
5317         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateFailure_IEs__value, choice.RANfunctionsIDcause_List),
5318                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5319                 0,
5320                 &asn_DEF_E2N_RANfunctionsIDcause_List,
5321                 0,
5322                 { 0, 0, 0 },
5323                 0, 0, /* No default value */
5324                 "RANfunctionsIDcause-List"
5325                 },
5326         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateFailure_IEs__value, choice.TimeToWait),
5327                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5328                 0,
5329                 &asn_DEF_E2N_TimeToWait,
5330                 0,
5331                 { 0, 0, 0 },
5332                 0, 0, /* No default value */
5333                 "TimeToWait"
5334                 },
5335         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
5336                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5337                 0,
5338                 &asn_DEF_E2N_CriticalityDiagnostics,
5339                 0,
5340                 { 0, 0, 0 },
5341                 0, 0, /* No default value */
5342                 "CriticalityDiagnostics"
5343                 },
5344 };
5345 static const unsigned asn_MAP_E2N_value_to_canonical_76[] = { 1, 0, 2 };
5346 static const unsigned asn_MAP_E2N_value_from_canonical_76[] = { 1, 0, 2 };
5347 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_76[] = {
5348     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
5349     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsIDcause-List */
5350     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* CriticalityDiagnostics */
5351 };
5352 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_76 = {
5353         sizeof(struct E2N_RICserviceUpdateFailure_IEs__value),
5354         offsetof(struct E2N_RICserviceUpdateFailure_IEs__value, _asn_ctx),
5355         offsetof(struct E2N_RICserviceUpdateFailure_IEs__value, present),
5356         sizeof(((struct E2N_RICserviceUpdateFailure_IEs__value *)0)->present),
5357         asn_MAP_E2N_value_tag2el_76,
5358         3,      /* Count of tags in the map */
5359         asn_MAP_E2N_value_to_canonical_76,
5360         asn_MAP_E2N_value_from_canonical_76,
5361         -1      /* Extensions start */
5362 };
5363 static /* Use -fall-defs-global to expose */
5364 asn_TYPE_descriptor_t asn_DEF_E2N_value_76 = {
5365         "value",
5366         "value",
5367         &asn_OP_OPEN_TYPE,
5368         0,      /* No effective tags (pointer) */
5369         0,      /* No effective tags (count) */
5370         0,      /* No tags (pointer) */
5371         0,      /* No tags (count) */
5372         { 0, 0, OPEN_TYPE_constraint },
5373         asn_MBR_E2N_value_76,
5374         3,      /* Elements count */
5375         &asn_SPC_E2N_value_specs_76     /* Additional specs */
5376 };
5377
5378 asn_TYPE_member_t asn_MBR_E2N_RICserviceUpdateFailure_IEs_73[] = {
5379         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateFailure_IEs, id),
5380                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5381                 -1,     /* IMPLICIT tag at current level */
5382                 &asn_DEF_E2N_ProtocolIE_ID,
5383                 0,
5384                 { 0, &asn_PER_memb_E2N_id_constr_74,  memb_E2N_id_constraint_73 },
5385                 0, 0, /* No default value */
5386                 "id"
5387                 },
5388         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateFailure_IEs, criticality),
5389                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5390                 -1,     /* IMPLICIT tag at current level */
5391                 &asn_DEF_E2N_Criticality,
5392                 select_RICserviceUpdateFailure_IEs_E2N_criticality_type,
5393                 { 0, &asn_PER_memb_E2N_criticality_constr_75,  memb_E2N_criticality_constraint_73 },
5394                 0, 0, /* No default value */
5395                 "criticality"
5396                 },
5397         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceUpdateFailure_IEs, value),
5398                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5399                 +1,     /* EXPLICIT tag at current level */
5400                 &asn_DEF_E2N_value_76,
5401                 select_RICserviceUpdateFailure_IEs_E2N_value_type,
5402                 { 0, &asn_PER_memb_E2N_value_constr_76,  memb_E2N_value_constraint_73 },
5403                 0, 0, /* No default value */
5404                 "value"
5405                 },
5406 };
5407 static const ber_tlv_tag_t asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73[] = {
5408         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5409 };
5410 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICserviceUpdateFailure_IEs_tag2el_73[] = {
5411     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5412     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5413     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5414 };
5415 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICserviceUpdateFailure_IEs_specs_73 = {
5416         sizeof(struct E2N_RICserviceUpdateFailure_IEs),
5417         offsetof(struct E2N_RICserviceUpdateFailure_IEs, _asn_ctx),
5418         asn_MAP_E2N_RICserviceUpdateFailure_IEs_tag2el_73,
5419         3,      /* Count of tags in the map */
5420         0, 0, 0,        /* Optional elements (not needed) */
5421         -1,     /* First extension addition */
5422 };
5423 asn_TYPE_descriptor_t asn_DEF_E2N_RICserviceUpdateFailure_IEs = {
5424         "RICserviceUpdateFailure-IEs",
5425         "RICserviceUpdateFailure-IEs",
5426         &asn_OP_SEQUENCE,
5427         asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73,
5428         sizeof(asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73)
5429                 /sizeof(asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73[0]), /* 1 */
5430         asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73,        /* Same as above */
5431         sizeof(asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73)
5432                 /sizeof(asn_DEF_E2N_RICserviceUpdateFailure_IEs_tags_73[0]), /* 1 */
5433         { 0, 0, SEQUENCE_constraint },
5434         asn_MBR_E2N_RICserviceUpdateFailure_IEs_73,
5435         3,      /* Elements count */
5436         &asn_SPC_E2N_RICserviceUpdateFailure_IEs_specs_73       /* Additional specs */
5437 };
5438
5439 static asn_TYPE_member_t asn_MBR_E2N_value_80[] = {
5440         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceQuery_IEs__value, choice.RANfunctionsID_List),
5441                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5442                 0,
5443                 &asn_DEF_E2N_RANfunctionsID_List,
5444                 0,
5445                 { 0, 0, 0 },
5446                 0, 0, /* No default value */
5447                 "RANfunctionsID-List"
5448                 },
5449 };
5450 static const asn_TYPE_tag2member_t asn_MAP_E2N_value_tag2el_80[] = {
5451     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionsID-List */
5452 };
5453 static asn_CHOICE_specifics_t asn_SPC_E2N_value_specs_80 = {
5454         sizeof(struct E2N_RICserviceQuery_IEs__value),
5455         offsetof(struct E2N_RICserviceQuery_IEs__value, _asn_ctx),
5456         offsetof(struct E2N_RICserviceQuery_IEs__value, present),
5457         sizeof(((struct E2N_RICserviceQuery_IEs__value *)0)->present),
5458         asn_MAP_E2N_value_tag2el_80,
5459         1,      /* Count of tags in the map */
5460         0, 0,
5461         -1      /* Extensions start */
5462 };
5463 static /* Use -fall-defs-global to expose */
5464 asn_TYPE_descriptor_t asn_DEF_E2N_value_80 = {
5465         "value",
5466         "value",
5467         &asn_OP_OPEN_TYPE,
5468         0,      /* No effective tags (pointer) */
5469         0,      /* No effective tags (count) */
5470         0,      /* No tags (pointer) */
5471         0,      /* No tags (count) */
5472         { 0, 0, OPEN_TYPE_constraint },
5473         asn_MBR_E2N_value_80,
5474         1,      /* Elements count */
5475         &asn_SPC_E2N_value_specs_80     /* Additional specs */
5476 };
5477
5478 asn_TYPE_member_t asn_MBR_E2N_RICserviceQuery_IEs_77[] = {
5479         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceQuery_IEs, id),
5480                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5481                 -1,     /* IMPLICIT tag at current level */
5482                 &asn_DEF_E2N_ProtocolIE_ID,
5483                 0,
5484                 { 0, &asn_PER_memb_E2N_id_constr_78,  memb_E2N_id_constraint_77 },
5485                 0, 0, /* No default value */
5486                 "id"
5487                 },
5488         { ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceQuery_IEs, criticality),
5489                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5490                 -1,     /* IMPLICIT tag at current level */
5491                 &asn_DEF_E2N_Criticality,
5492                 select_RICserviceQuery_IEs_E2N_criticality_type,
5493                 { 0, &asn_PER_memb_E2N_criticality_constr_79,  memb_E2N_criticality_constraint_77 },
5494                 0, 0, /* No default value */
5495                 "criticality"
5496                 },
5497         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2N_RICserviceQuery_IEs, value),
5498                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5499                 +1,     /* EXPLICIT tag at current level */
5500                 &asn_DEF_E2N_value_80,
5501                 select_RICserviceQuery_IEs_E2N_value_type,
5502                 { 0, &asn_PER_memb_E2N_value_constr_80,  memb_E2N_value_constraint_77 },
5503                 0, 0, /* No default value */
5504                 "value"
5505                 },
5506 };
5507 static const ber_tlv_tag_t asn_DEF_E2N_RICserviceQuery_IEs_tags_77[] = {
5508         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5509 };
5510 static const asn_TYPE_tag2member_t asn_MAP_E2N_RICserviceQuery_IEs_tag2el_77[] = {
5511     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5512     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5513     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5514 };
5515 asn_SEQUENCE_specifics_t asn_SPC_E2N_RICserviceQuery_IEs_specs_77 = {
5516         sizeof(struct E2N_RICserviceQuery_IEs),
5517         offsetof(struct E2N_RICserviceQuery_IEs, _asn_ctx),
5518         asn_MAP_E2N_RICserviceQuery_IEs_tag2el_77,
5519         3,      /* Count of tags in the map */
5520         0, 0, 0,        /* Optional elements (not needed) */
5521         -1,     /* First extension addition */
5522 };
5523 asn_TYPE_descriptor_t asn_DEF_E2N_RICserviceQuery_IEs = {
5524         "RICserviceQuery-IEs",
5525         "RICserviceQuery-IEs",
5526         &asn_OP_SEQUENCE,
5527         asn_DEF_E2N_RICserviceQuery_IEs_tags_77,
5528         sizeof(asn_DEF_E2N_RICserviceQuery_IEs_tags_77)
5529                 /sizeof(asn_DEF_E2N_RICserviceQuery_IEs_tags_77[0]), /* 1 */
5530         asn_DEF_E2N_RICserviceQuery_IEs_tags_77,        /* Same as above */
5531         sizeof(asn_DEF_E2N_RICserviceQuery_IEs_tags_77)
5532                 /sizeof(asn_DEF_E2N_RICserviceQuery_IEs_tags_77[0]), /* 1 */
5533         { 0, 0, SEQUENCE_constraint },
5534         asn_MBR_E2N_RICserviceQuery_IEs_77,
5535         3,      /* Elements count */
5536         &asn_SPC_E2N_RICserviceQuery_IEs_specs_77       /* Additional specs */
5537 };
5538