e2ap/lib/ProtocolIE-Field.c

   1 /*
   2  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
   3  * From ASN.1 module "E2AP-Containers"
   4  *      found in "E2AP-Containers-v01.00.asn"
   5  *      `asn1c -pdu=auto -fno-include-deps -fcompound-names -findirect-choice -gen-PER -gen-OER -no-gen-example`
   6  */
   7
   8 #include "ProtocolIE-Field.h"
   9
  10 static const long asn_VAL_4_id_RICaction_ToBeSetup_Item = 19;
  11 static const long asn_VAL_4_ignore = 1;
  12 static const long asn_VAL_4_mandatory = 2;
  13 static const asn_ioc_cell_t asn_IOS_RICaction_ToBeSetup_ItemIEs_1_rows[] = {
  14         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_4_id_RICaction_ToBeSetup_Item },
  15         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_4_ignore },
  16         { "&Value", aioc__type, &asn_DEF_RICaction_ToBeSetup_Item },
  17         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_4_mandatory }
  18 };
  19 static const asn_ioc_set_t asn_IOS_RICaction_ToBeSetup_ItemIEs_1[] = {
  20         { 1, 4, asn_IOS_RICaction_ToBeSetup_ItemIEs_1_rows }
  21 };
  22 static const long asn_VAL_9_id_RICaction_Admitted_Item = 14;
  23 static const long asn_VAL_9_ignore = 1;
  24 static const long asn_VAL_9_mandatory = 2;
  25 static const asn_ioc_cell_t asn_IOS_RICaction_Admitted_ItemIEs_1_rows[] = {
  26         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_9_id_RICaction_Admitted_Item },
  27         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_9_ignore },
  28         { "&Value", aioc__type, &asn_DEF_RICaction_Admitted_Item },
  29         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_9_mandatory }
  30 };
  31 static const asn_ioc_set_t asn_IOS_RICaction_Admitted_ItemIEs_1[] = {
  32         { 1, 4, asn_IOS_RICaction_Admitted_ItemIEs_1_rows }
  33 };
  34 static const long asn_VAL_10_id_RICaction_NotAdmitted_Item = 16;
  35 static const long asn_VAL_10_ignore = 1;
  36 static const long asn_VAL_10_mandatory = 2;
  37 static const asn_ioc_cell_t asn_IOS_RICaction_NotAdmitted_ItemIEs_1_rows[] = {
  38         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_10_id_RICaction_NotAdmitted_Item },
  39         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_10_ignore },
  40         { "&Value", aioc__type, &asn_DEF_RICaction_NotAdmitted_Item },
  41         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_10_mandatory }
  42 };
  43 static const asn_ioc_set_t asn_IOS_RICaction_NotAdmitted_ItemIEs_1[] = {
  44         { 1, 4, asn_IOS_RICaction_NotAdmitted_ItemIEs_1_rows }
  45 };
  46 static const long asn_VAL_64_id_RANfunction_Item = 8;
  47 static const long asn_VAL_64_ignore = 1;
  48 static const long asn_VAL_64_mandatory = 2;
  49 static const asn_ioc_cell_t asn_IOS_RANfunction_ItemIEs_1_rows[] = {
  50         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_64_id_RANfunction_Item },
  51         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_64_ignore },
  52         { "&Value", aioc__type, &asn_DEF_RANfunction_Item },
  53         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_64_mandatory }
  54 };
  55 static const asn_ioc_set_t asn_IOS_RANfunction_ItemIEs_1[] = {
  56         { 1, 4, asn_IOS_RANfunction_ItemIEs_1_rows }
  57 };
  58 static const long asn_VAL_65_id_RANfunctionID_Item = 6;
  59 static const long asn_VAL_65_ignore = 1;
  60 static const long asn_VAL_65_mandatory = 2;
  61 static const asn_ioc_cell_t asn_IOS_RANfunctionID_ItemIEs_1_rows[] = {
  62         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_65_id_RANfunctionID_Item },
  63         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_65_ignore },
  64         { "&Value", aioc__type, &asn_DEF_RANfunctionID_Item },
  65         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_65_mandatory }
  66 };
  67 static const asn_ioc_set_t asn_IOS_RANfunctionID_ItemIEs_1[] = {
  68         { 1, 4, asn_IOS_RANfunctionID_ItemIEs_1_rows }
  69 };
  70 static const long asn_VAL_68_id_RANfunctionIEcause_Item = 7;
  71 static const long asn_VAL_68_ignore = 1;
  72 static const long asn_VAL_68_mandatory = 2;
  73 static const asn_ioc_cell_t asn_IOS_RANfunctionIDcause_ItemIEs_1_rows[] = {
  74         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_68_id_RANfunctionIEcause_Item },
  75         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_68_ignore },
  76         { "&Value", aioc__type, &asn_DEF_RANfunctionIDcause_Item },
  77         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_68_mandatory }
  78 };
  79 static const asn_ioc_set_t asn_IOS_RANfunctionIDcause_ItemIEs_1[] = {
  80         { 1, 4, asn_IOS_RANfunctionIDcause_ItemIEs_1_rows }
  81 };
  82 static const long asn_VAL_1_id_RICrequestID = 29;
  83 static const long asn_VAL_1_reject = 0;
  84 static const long asn_VAL_1_mandatory = 2;
  85 static const long asn_VAL_2_id_RANfunctionID = 5;
  86 static const long asn_VAL_2_reject = 0;
  87 static const long asn_VAL_2_mandatory = 2;
  88 static const long asn_VAL_3_id_RICsubscriptionDetails = 30;
  89 static const long asn_VAL_3_reject = 0;
  90 static const long asn_VAL_3_mandatory = 2;
  91 static const asn_ioc_cell_t asn_IOS_RICsubscriptionRequest_IEs_1_rows[] = {
  92         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_1_id_RICrequestID },
  93         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_1_reject },
  94         { "&Value", aioc__type, &asn_DEF_RICrequestID },
  95         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_1_mandatory },
  96         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_2_id_RANfunctionID },
  97         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_2_reject },
  98         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
  99         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_2_mandatory },
 100         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_3_id_RICsubscriptionDetails },
 101         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_3_reject },
 102         { "&Value", aioc__type, &asn_DEF_RICsubscriptionDetails },
 103         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_3_mandatory }
 104 };
 105 static const asn_ioc_set_t asn_IOS_RICsubscriptionRequest_IEs_1[] = {
 106         { 3, 4, asn_IOS_RICsubscriptionRequest_IEs_1_rows }
 107 };
 108 static const long asn_VAL_5_id_RICrequestID = 29;
 109 static const long asn_VAL_5_reject = 0;
 110 static const long asn_VAL_5_mandatory = 2;
 111 static const long asn_VAL_6_id_RANfunctionID = 5;
 112 static const long asn_VAL_6_reject = 0;
 113 static const long asn_VAL_6_mandatory = 2;
 114 static const long asn_VAL_7_id_RICactions_Admitted = 17;
 115 static const long asn_VAL_7_reject = 0;
 116 static const long asn_VAL_7_mandatory = 2;
 117 static const long asn_VAL_8_id_RICactions_NotAdmitted = 18;
 118 static const long asn_VAL_8_reject = 0;
 119 static const long asn_VAL_8_optional = 0;
 120 static const asn_ioc_cell_t asn_IOS_RICsubscriptionResponse_IEs_1_rows[] = {
 121         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_5_id_RICrequestID },
 122         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_5_reject },
 123         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 124         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_5_mandatory },
 125         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_6_id_RANfunctionID },
 126         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_6_reject },
 127         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 128         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_6_mandatory },
 129         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_7_id_RICactions_Admitted },
 130         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_7_reject },
 131         { "&Value", aioc__type, &asn_DEF_RICaction_Admitted_List },
 132         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_7_mandatory },
 133         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_8_id_RICactions_NotAdmitted },
 134         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_8_reject },
 135         { "&Value", aioc__type, &asn_DEF_RICaction_NotAdmitted_List },
 136         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_8_optional }
 137 };
 138 static const asn_ioc_set_t asn_IOS_RICsubscriptionResponse_IEs_1[] = {
 139         { 4, 4, asn_IOS_RICsubscriptionResponse_IEs_1_rows }
 140 };
 141 static const long asn_VAL_11_id_RICrequestID = 29;
 142 static const long asn_VAL_11_reject = 0;
 143 static const long asn_VAL_11_mandatory = 2;
 144 static const long asn_VAL_12_id_RANfunctionID = 5;
 145 static const long asn_VAL_12_reject = 0;
 146 static const long asn_VAL_12_mandatory = 2;
 147 static const long asn_VAL_13_id_RICactions_NotAdmitted = 18;
 148 static const long asn_VAL_13_reject = 0;
 149 static const long asn_VAL_13_mandatory = 2;
 150 static const long asn_VAL_14_id_CriticalityDiagnostics = 2;
 151 static const long asn_VAL_14_ignore = 1;
 152 static const long asn_VAL_14_optional = 0;
 153 static const asn_ioc_cell_t asn_IOS_RICsubscriptionFailure_IEs_1_rows[] = {
 154         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_11_id_RICrequestID },
 155         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_11_reject },
 156         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 157         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_11_mandatory },
 158         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_12_id_RANfunctionID },
 159         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_12_reject },
 160         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 161         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_12_mandatory },
 162         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_13_id_RICactions_NotAdmitted },
 163         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_13_reject },
 164         { "&Value", aioc__type, &asn_DEF_RICaction_NotAdmitted_List },
 165         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_13_mandatory },
 166         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_14_id_CriticalityDiagnostics },
 167         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_14_ignore },
 168         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 169         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_14_optional }
 170 };
 171 static const asn_ioc_set_t asn_IOS_RICsubscriptionFailure_IEs_1[] = {
 172         { 4, 4, asn_IOS_RICsubscriptionFailure_IEs_1_rows }
 173 };
 174 static const long asn_VAL_15_id_RICrequestID = 29;
 175 static const long asn_VAL_15_reject = 0;
 176 static const long asn_VAL_15_mandatory = 2;
 177 static const long asn_VAL_16_id_RANfunctionID = 5;
 178 static const long asn_VAL_16_reject = 0;
 179 static const long asn_VAL_16_mandatory = 2;
 180 static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteRequest_IEs_1_rows[] = {
 181         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_15_id_RICrequestID },
 182         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_15_reject },
 183         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 184         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_15_mandatory },
 185         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_16_id_RANfunctionID },
 186         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_16_reject },
 187         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 188         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_16_mandatory }
 189 };
 190 static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteRequest_IEs_1[] = {
 191         { 2, 4, asn_IOS_RICsubscriptionDeleteRequest_IEs_1_rows }
 192 };
 193 static const long asn_VAL_17_id_RICrequestID = 29;
 194 static const long asn_VAL_17_reject = 0;
 195 static const long asn_VAL_17_mandatory = 2;
 196 static const long asn_VAL_18_id_RANfunctionID = 5;
 197 static const long asn_VAL_18_reject = 0;
 198 static const long asn_VAL_18_mandatory = 2;
 199 static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteResponse_IEs_1_rows[] = {
 200         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_17_id_RICrequestID },
 201         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_17_reject },
 202         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 203         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_17_mandatory },
 204         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_18_id_RANfunctionID },
 205         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_18_reject },
 206         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 207         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_18_mandatory }
 208 };
 209 static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteResponse_IEs_1[] = {
 210         { 2, 4, asn_IOS_RICsubscriptionDeleteResponse_IEs_1_rows }
 211 };
 212 static const long asn_VAL_19_id_RICrequestID = 29;
 213 static const long asn_VAL_19_reject = 0;
 214 static const long asn_VAL_19_mandatory = 2;
 215 static const long asn_VAL_20_id_RANfunctionID = 5;
 216 static const long asn_VAL_20_reject = 0;
 217 static const long asn_VAL_20_mandatory = 2;
 218 static const long asn_VAL_21_id_Cause = 1;
 219 static const long asn_VAL_21_ignore = 1;
 220 static const long asn_VAL_21_mandatory = 2;
 221 static const long asn_VAL_22_id_CriticalityDiagnostics = 2;
 222 static const long asn_VAL_22_ignore = 1;
 223 static const long asn_VAL_22_optional = 0;
 224 static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteFailure_IEs_1_rows[] = {
 225         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_19_id_RICrequestID },
 226         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_19_reject },
 227         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 228         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_19_mandatory },
 229         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_20_id_RANfunctionID },
 230         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_20_reject },
 231         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 232         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_20_mandatory },
 233         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_21_id_Cause },
 234         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_21_ignore },
 235         { "&Value", aioc__type, &asn_DEF_Cause },
 236         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_21_mandatory },
 237         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_22_id_CriticalityDiagnostics },
 238         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_22_ignore },
 239         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 240         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_22_optional }
 241 };
 242 static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteFailure_IEs_1[] = {
 243         { 4, 4, asn_IOS_RICsubscriptionDeleteFailure_IEs_1_rows }
 244 };
 245 static const long asn_VAL_23_id_RICrequestID = 29;
 246 static const long asn_VAL_23_reject = 0;
 247 static const long asn_VAL_23_mandatory = 2;
 248 static const long asn_VAL_24_id_RANfunctionID = 5;
 249 static const long asn_VAL_24_reject = 0;
 250 static const long asn_VAL_24_mandatory = 2;
 251 static const long asn_VAL_25_id_RICactionID = 15;
 252 static const long asn_VAL_25_reject = 0;
 253 static const long asn_VAL_25_mandatory = 2;
 254 static const long asn_VAL_26_id_RICindicationSN = 27;
 255 static const long asn_VAL_26_reject = 0;
 256 static const long asn_VAL_26_optional = 0;
 257 static const long asn_VAL_27_id_RICindicationType = 28;
 258 static const long asn_VAL_27_reject = 0;
 259 static const long asn_VAL_27_mandatory = 2;
 260 static const long asn_VAL_28_id_RICindicationHeader = 25;
 261 static const long asn_VAL_28_reject = 0;
 262 static const long asn_VAL_28_mandatory = 2;
 263 static const long asn_VAL_29_id_RICindicationMessage = 26;
 264 static const long asn_VAL_29_reject = 0;
 265 static const long asn_VAL_29_mandatory = 2;
 266 static const long asn_VAL_30_id_RICcallProcessID = 20;
 267 static const long asn_VAL_30_reject = 0;
 268 static const long asn_VAL_30_optional = 0;
 269 static const asn_ioc_cell_t asn_IOS_RICindication_IEs_1_rows[] = {
 270         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_23_id_RICrequestID },
 271         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_23_reject },
 272         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 273         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_23_mandatory },
 274         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_24_id_RANfunctionID },
 275         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_24_reject },
 276         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 277         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_24_mandatory },
 278         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_25_id_RICactionID },
 279         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_25_reject },
 280         { "&Value", aioc__type, &asn_DEF_RICactionID },
 281         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_25_mandatory },
 282         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_26_id_RICindicationSN },
 283         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_26_reject },
 284         { "&Value", aioc__type, &asn_DEF_RICindicationSN },
 285         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_26_optional },
 286         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_27_id_RICindicationType },
 287         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_27_reject },
 288         { "&Value", aioc__type, &asn_DEF_RICindicationType },
 289         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_27_mandatory },
 290         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_28_id_RICindicationHeader },
 291         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_28_reject },
 292         { "&Value", aioc__type, &asn_DEF_RICindicationHeader },
 293         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_28_mandatory },
 294         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_29_id_RICindicationMessage },
 295         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_29_reject },
 296         { "&Value", aioc__type, &asn_DEF_RICindicationMessage },
 297         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_29_mandatory },
 298         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_30_id_RICcallProcessID },
 299         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_30_reject },
 300         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 301         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_30_optional }
 302 };
 303 static const asn_ioc_set_t asn_IOS_RICindication_IEs_1[] = {
 304         { 8, 4, asn_IOS_RICindication_IEs_1_rows }
 305 };
 306 static const long asn_VAL_31_id_RICrequestID = 29;
 307 static const long asn_VAL_31_reject = 0;
 308 static const long asn_VAL_31_mandatory = 2;
 309 static const long asn_VAL_32_id_RANfunctionID = 5;
 310 static const long asn_VAL_32_reject = 0;
 311 static const long asn_VAL_32_mandatory = 2;
 312 static const long asn_VAL_33_id_RICcallProcessID = 20;
 313 static const long asn_VAL_33_reject = 0;
 314 static const long asn_VAL_33_optional = 0;
 315 static const long asn_VAL_34_id_RICcontrolHeader = 22;
 316 static const long asn_VAL_34_reject = 0;
 317 static const long asn_VAL_34_mandatory = 2;
 318 static const long asn_VAL_35_id_RICcontrolMessage = 23;
 319 static const long asn_VAL_35_reject = 0;
 320 static const long asn_VAL_35_mandatory = 2;
 321 static const long asn_VAL_36_id_RICcontrolAckRequest = 21;
 322 static const long asn_VAL_36_reject = 0;
 323 static const long asn_VAL_36_optional = 0;
 324 static const asn_ioc_cell_t asn_IOS_RICcontrolRequest_IEs_1_rows[] = {
 325         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_31_id_RICrequestID },
 326         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_31_reject },
 327         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 328         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_31_mandatory },
 329         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_32_id_RANfunctionID },
 330         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_32_reject },
 331         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 332         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_32_mandatory },
 333         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_33_id_RICcallProcessID },
 334         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_33_reject },
 335         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 336         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_33_optional },
 337         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_34_id_RICcontrolHeader },
 338         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_34_reject },
 339         { "&Value", aioc__type, &asn_DEF_RICcontrolHeader },
 340         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_34_mandatory },
 341         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_35_id_RICcontrolMessage },
 342         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_35_reject },
 343         { "&Value", aioc__type, &asn_DEF_RICcontrolMessage },
 344         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_35_mandatory },
 345         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_36_id_RICcontrolAckRequest },
 346         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_36_reject },
 347         { "&Value", aioc__type, &asn_DEF_RICcontrolAckRequest },
 348         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_36_optional }
 349 };
 350 static const asn_ioc_set_t asn_IOS_RICcontrolRequest_IEs_1[] = {
 351         { 6, 4, asn_IOS_RICcontrolRequest_IEs_1_rows }
 352 };
 353 static const long asn_VAL_37_id_RICrequestID = 29;
 354 static const long asn_VAL_37_reject = 0;
 355 static const long asn_VAL_37_mandatory = 2;
 356 static const long asn_VAL_38_id_RANfunctionID = 5;
 357 static const long asn_VAL_38_reject = 0;
 358 static const long asn_VAL_38_mandatory = 2;
 359 static const long asn_VAL_39_id_RICcallProcessID = 20;
 360 static const long asn_VAL_39_reject = 0;
 361 static const long asn_VAL_39_optional = 0;
 362 static const long asn_VAL_40_id_RICcontrolStatus = 24;
 363 static const long asn_VAL_40_reject = 0;
 364 static const long asn_VAL_40_mandatory = 2;
 365 static const long asn_VAL_41_id_RICcontrolOutcome = 32;
 366 static const long asn_VAL_41_reject = 0;
 367 static const long asn_VAL_41_optional = 0;
 368 static const asn_ioc_cell_t asn_IOS_RICcontrolAcknowledge_IEs_1_rows[] = {
 369         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_37_id_RICrequestID },
 370         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_37_reject },
 371         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 372         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_37_mandatory },
 373         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_38_id_RANfunctionID },
 374         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_38_reject },
 375         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 376         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_38_mandatory },
 377         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_39_id_RICcallProcessID },
 378         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_39_reject },
 379         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 380         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_39_optional },
 381         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_40_id_RICcontrolStatus },
 382         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_40_reject },
 383         { "&Value", aioc__type, &asn_DEF_RICcontrolStatus },
 384         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_40_mandatory },
 385         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_41_id_RICcontrolOutcome },
 386         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_41_reject },
 387         { "&Value", aioc__type, &asn_DEF_RICcontrolOutcome },
 388         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_41_optional }
 389 };
 390 static const asn_ioc_set_t asn_IOS_RICcontrolAcknowledge_IEs_1[] = {
 391         { 5, 4, asn_IOS_RICcontrolAcknowledge_IEs_1_rows }
 392 };
 393 static const long asn_VAL_42_id_RICrequestID = 29;
 394 static const long asn_VAL_42_reject = 0;
 395 static const long asn_VAL_42_mandatory = 2;
 396 static const long asn_VAL_43_id_RANfunctionID = 5;
 397 static const long asn_VAL_43_reject = 0;
 398 static const long asn_VAL_43_mandatory = 2;
 399 static const long asn_VAL_44_id_RICcallProcessID = 20;
 400 static const long asn_VAL_44_reject = 0;
 401 static const long asn_VAL_44_optional = 0;
 402 static const long asn_VAL_45_id_Cause = 1;
 403 static const long asn_VAL_45_ignore = 1;
 404 static const long asn_VAL_45_mandatory = 2;
 405 static const long asn_VAL_46_id_RICcontrolOutcome = 32;
 406 static const long asn_VAL_46_reject = 0;
 407 static const long asn_VAL_46_optional = 0;
 408 static const asn_ioc_cell_t asn_IOS_RICcontrolFailure_IEs_1_rows[] = {
 409         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_42_id_RICrequestID },
 410         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_42_reject },
 411         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 412         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_42_mandatory },
 413         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_43_id_RANfunctionID },
 414         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_43_reject },
 415         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 416         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_43_mandatory },
 417         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_44_id_RICcallProcessID },
 418         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_44_reject },
 419         { "&Value", aioc__type, &asn_DEF_RICcallProcessID },
 420         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_44_optional },
 421         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_45_id_Cause },
 422         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_45_ignore },
 423         { "&Value", aioc__type, &asn_DEF_Cause },
 424         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_45_mandatory },
 425         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_46_id_RICcontrolOutcome },
 426         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_46_reject },
 427         { "&Value", aioc__type, &asn_DEF_RICcontrolOutcome },
 428         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_46_optional }
 429 };
 430 static const asn_ioc_set_t asn_IOS_RICcontrolFailure_IEs_1[] = {
 431         { 5, 4, asn_IOS_RICcontrolFailure_IEs_1_rows }
 432 };
 433 static const long asn_VAL_47_id_RICrequestID = 29;
 434 static const long asn_VAL_47_reject = 0;
 435 static const long asn_VAL_47_optional = 0;
 436 static const long asn_VAL_48_id_RANfunctionID = 5;
 437 static const long asn_VAL_48_reject = 0;
 438 static const long asn_VAL_48_optional = 0;
 439 static const long asn_VAL_49_id_Cause = 1;
 440 static const long asn_VAL_49_ignore = 1;
 441 static const long asn_VAL_49_optional = 0;
 442 static const long asn_VAL_50_id_CriticalityDiagnostics = 2;
 443 static const long asn_VAL_50_ignore = 1;
 444 static const long asn_VAL_50_optional = 0;
 445 static const asn_ioc_cell_t asn_IOS_ErrorIndication_IEs_1_rows[] = {
 446         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_47_id_RICrequestID },
 447         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_47_reject },
 448         { "&Value", aioc__type, &asn_DEF_RICrequestID },
 449         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_47_optional },
 450         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_48_id_RANfunctionID },
 451         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_48_reject },
 452         { "&Value", aioc__type, &asn_DEF_RANfunctionID },
 453         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_48_optional },
 454         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_49_id_Cause },
 455         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_49_ignore },
 456         { "&Value", aioc__type, &asn_DEF_Cause },
 457         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_49_optional },
 458         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_50_id_CriticalityDiagnostics },
 459         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_50_ignore },
 460         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 461         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_50_optional }
 462 };
 463 static const asn_ioc_set_t asn_IOS_ErrorIndication_IEs_1[] = {
 464         { 4, 4, asn_IOS_ErrorIndication_IEs_1_rows }
 465 };
 466 static const long asn_VAL_51_id_GlobalE2node_ID = 3;
 467 static const long asn_VAL_51_reject = 0;
 468 static const long asn_VAL_51_mandatory = 2;
 469 static const long asn_VAL_52_id_RANfunctionsAdded = 10;
 470 static const long asn_VAL_52_reject = 0;
 471 static const long asn_VAL_52_optional = 0;
 472 static const asn_ioc_cell_t asn_IOS_E2setupRequestIEs_1_rows[] = {
 473         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_51_id_GlobalE2node_ID },
 474         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_51_reject },
 475         { "&Value", aioc__type, &asn_DEF_GlobalE2node_ID },
 476         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_51_mandatory },
 477         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_52_id_RANfunctionsAdded },
 478         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_52_reject },
 479         { "&Value", aioc__type, &asn_DEF_RANfunctions_List },
 480         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_52_optional }
 481 };
 482 static const asn_ioc_set_t asn_IOS_E2setupRequestIEs_1[] = {
 483         { 2, 4, asn_IOS_E2setupRequestIEs_1_rows }
 484 };
 485 static const long asn_VAL_53_id_GlobalRIC_ID = 4;
 486 static const long asn_VAL_53_reject = 0;
 487 static const long asn_VAL_53_mandatory = 2;
 488 static const long asn_VAL_54_id_RANfunctionsAccepted = 9;
 489 static const long asn_VAL_54_reject = 0;
 490 static const long asn_VAL_54_optional = 0;
 491 static const long asn_VAL_55_id_RANfunctionsRejected = 13;
 492 static const long asn_VAL_55_reject = 0;
 493 static const long asn_VAL_55_optional = 0;
 494 static const asn_ioc_cell_t asn_IOS_E2setupResponseIEs_1_rows[] = {
 495         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_53_id_GlobalRIC_ID },
 496         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_53_reject },
 497         { "&Value", aioc__type, &asn_DEF_GlobalRIC_ID },
 498         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_53_mandatory },
 499         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_54_id_RANfunctionsAccepted },
 500         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_54_reject },
 501         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 502         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_54_optional },
 503         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_55_id_RANfunctionsRejected },
 504         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_55_reject },
 505         { "&Value", aioc__type, &asn_DEF_RANfunctionsIDcause_List },
 506         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_55_optional }
 507 };
 508 static const asn_ioc_set_t asn_IOS_E2setupResponseIEs_1[] = {
 509         { 3, 4, asn_IOS_E2setupResponseIEs_1_rows }
 510 };
 511 static const long asn_VAL_56_id_Cause = 1;
 512 static const long asn_VAL_56_ignore = 1;
 513 static const long asn_VAL_56_mandatory = 2;
 514 static const long asn_VAL_57_id_TimeToWait = 31;
 515 static const long asn_VAL_57_ignore = 1;
 516 static const long asn_VAL_57_optional = 0;
 517 static const long asn_VAL_58_id_CriticalityDiagnostics = 2;
 518 static const long asn_VAL_58_ignore = 1;
 519 static const long asn_VAL_58_optional = 0;
 520 static const asn_ioc_cell_t asn_IOS_E2setupFailureIEs_1_rows[] = {
 521         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_56_id_Cause },
 522         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_56_ignore },
 523         { "&Value", aioc__type, &asn_DEF_Cause },
 524         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_56_mandatory },
 525         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_57_id_TimeToWait },
 526         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_57_ignore },
 527         { "&Value", aioc__type, &asn_DEF_TimeToWait },
 528         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_57_optional },
 529         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_58_id_CriticalityDiagnostics },
 530         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_58_ignore },
 531         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 532         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_58_optional }
 533 };
 534 static const asn_ioc_set_t asn_IOS_E2setupFailureIEs_1[] = {
 535         { 3, 4, asn_IOS_E2setupFailureIEs_1_rows }
 536 };
 537 static const long asn_VAL_59_id_Cause = 1;
 538 static const long asn_VAL_59_ignore = 1;
 539 static const long asn_VAL_59_mandatory = 2;
 540 static const asn_ioc_cell_t asn_IOS_ResetRequestIEs_1_rows[] = {
 541         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_59_id_Cause },
 542         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_59_ignore },
 543         { "&Value", aioc__type, &asn_DEF_Cause },
 544         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_59_mandatory }
 545 };
 546 static const asn_ioc_set_t asn_IOS_ResetRequestIEs_1[] = {
 547         { 1, 4, asn_IOS_ResetRequestIEs_1_rows }
 548 };
 549 static const long asn_VAL_60_id_CriticalityDiagnostics = 2;
 550 static const long asn_VAL_60_ignore = 1;
 551 static const long asn_VAL_60_optional = 0;
 552 static const asn_ioc_cell_t asn_IOS_ResetResponseIEs_1_rows[] = {
 553         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_60_id_CriticalityDiagnostics },
 554         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_60_ignore },
 555         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 556         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_60_optional }
 557 };
 558 static const asn_ioc_set_t asn_IOS_ResetResponseIEs_1[] = {
 559         { 1, 4, asn_IOS_ResetResponseIEs_1_rows }
 560 };
 561 static const long asn_VAL_61_id_RANfunctionsAdded = 10;
 562 static const long asn_VAL_61_reject = 0;
 563 static const long asn_VAL_61_optional = 0;
 564 static const long asn_VAL_62_id_RANfunctionsModified = 12;
 565 static const long asn_VAL_62_reject = 0;
 566 static const long asn_VAL_62_optional = 0;
 567 static const long asn_VAL_63_id_RANfunctionsDeleted = 11;
 568 static const long asn_VAL_63_reject = 0;
 569 static const long asn_VAL_63_optional = 0;
 570 static const asn_ioc_cell_t asn_IOS_RICserviceUpdate_IEs_1_rows[] = {
 571         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_61_id_RANfunctionsAdded },
 572         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_61_reject },
 573         { "&Value", aioc__type, &asn_DEF_RANfunctions_List },
 574         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_61_optional },
 575         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_62_id_RANfunctionsModified },
 576         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_62_reject },
 577         { "&Value", aioc__type, &asn_DEF_RANfunctions_List },
 578         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_62_optional },
 579         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_63_id_RANfunctionsDeleted },
 580         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_63_reject },
 581         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 582         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_63_optional }
 583 };
 584 static const asn_ioc_set_t asn_IOS_RICserviceUpdate_IEs_1[] = {
 585         { 3, 4, asn_IOS_RICserviceUpdate_IEs_1_rows }
 586 };
 587 static const long asn_VAL_66_id_RANfunctionsAccepted = 9;
 588 static const long asn_VAL_66_reject = 0;
 589 static const long asn_VAL_66_optional = 0;
 590 static const long asn_VAL_67_id_RANfunctionsRejected = 13;
 591 static const long asn_VAL_67_reject = 0;
 592 static const long asn_VAL_67_optional = 0;
 593 static const asn_ioc_cell_t asn_IOS_RICserviceUpdateAcknowledge_IEs_1_rows[] = {
 594         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_66_id_RANfunctionsAccepted },
 595         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_66_reject },
 596         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 597         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_66_optional },
 598         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_67_id_RANfunctionsRejected },
 599         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_67_reject },
 600         { "&Value", aioc__type, &asn_DEF_RANfunctionsIDcause_List },
 601         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_67_optional }
 602 };
 603 static const asn_ioc_set_t asn_IOS_RICserviceUpdateAcknowledge_IEs_1[] = {
 604         { 2, 4, asn_IOS_RICserviceUpdateAcknowledge_IEs_1_rows }
 605 };
 606 static const long asn_VAL_69_id_RANfunctionsRejected = 13;
 607 static const long asn_VAL_69_ignore = 1;
 608 static const long asn_VAL_69_optional = 0;
 609 static const long asn_VAL_70_id_TimeToWait = 31;
 610 static const long asn_VAL_70_ignore = 1;
 611 static const long asn_VAL_70_optional = 0;
 612 static const long asn_VAL_71_id_CriticalityDiagnostics = 2;
 613 static const long asn_VAL_71_ignore = 1;
 614 static const long asn_VAL_71_optional = 0;
 615 static const asn_ioc_cell_t asn_IOS_RICserviceUpdateFailure_IEs_1_rows[] = {
 616         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_69_id_RANfunctionsRejected },
 617         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_69_ignore },
 618         { "&Value", aioc__type, &asn_DEF_RANfunctionsIDcause_List },
 619         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_69_optional },
 620         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_70_id_TimeToWait },
 621         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_70_ignore },
 622         { "&Value", aioc__type, &asn_DEF_TimeToWait },
 623         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_70_optional },
 624         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_71_id_CriticalityDiagnostics },
 625         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_71_ignore },
 626         { "&Value", aioc__type, &asn_DEF_CriticalityDiagnostics },
 627         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_71_optional }
 628 };
 629 static const asn_ioc_set_t asn_IOS_RICserviceUpdateFailure_IEs_1[] = {
 630         { 3, 4, asn_IOS_RICserviceUpdateFailure_IEs_1_rows }
 631 };
 632 static const long asn_VAL_72_id_RANfunctionsAccepted = 9;
 633 static const long asn_VAL_72_reject = 0;
 634 static const long asn_VAL_72_optional = 0;
 635 static const asn_ioc_cell_t asn_IOS_RICserviceQuery_IEs_1_rows[] = {
 636         { "&id", aioc__value, &asn_DEF_ProtocolIE_ID, &asn_VAL_72_id_RANfunctionsAccepted },
 637         { "&criticality", aioc__value, &asn_DEF_Criticality, &asn_VAL_72_reject },
 638         { "&Value", aioc__type, &asn_DEF_RANfunctionsID_List },
 639         { "&presence", aioc__value, &asn_DEF_Presence, &asn_VAL_72_optional }
 640 };
 641 static const asn_ioc_set_t asn_IOS_RICserviceQuery_IEs_1[] = {
 642         { 1, 4, asn_IOS_RICserviceQuery_IEs_1_rows }
 643 };
 644 static int
 645 memb_id_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 646                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 647         long value;
 648
 649         if(!sptr) {
 650                 ASN__CTFAIL(app_key, td, sptr,
 651                         "%s: value not given (%s:%d)",
 652                         td->name, __FILE__, __LINE__);
 653                 return -1;
 654         }
 655
 656         value = *(const long *)sptr;
 657
 658         if((value >= 0 && value <= 65535)) {
 659                 /* Constraint check succeeded */
 660                 return 0;
 661         } else {
 662                 ASN__CTFAIL(app_key, td, sptr,
 663                         "%s: constraint failed (%s:%d)",
 664                         td->name, __FILE__, __LINE__);
 665                 return -1;
 666         }
 667 }
 668
 669 static asn_type_selector_result_t
 670 select_RICaction_ToBeSetup_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 671         asn_type_selector_result_t result = {0, 0};
 672         const asn_ioc_set_t *itable = asn_IOS_RICaction_ToBeSetup_ItemIEs_1;
 673         size_t constraining_column = 0; /* &id */
 674         size_t for_column = 1; /* &criticality */
 675         size_t row, presence_index = 0;
 676         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_ToBeSetup_ItemIEs, id));
 677
 678         for(row=0; row < itable->rows_count; row++) {
 679             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 680             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 681
 682             if(type_cell->cell_kind == aioc__undefined)
 683                 continue;
 684
 685             presence_index++;
 686             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 687                 result.type_descriptor = type_cell->type_descriptor;
 688                 result.presence_index = presence_index;
 689                 break;
 690             }
 691         }
 692
 693         return result;
 694 }
 695
 696 static int
 697 memb_criticality_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 698                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 699
 700         if(!sptr) {
 701                 ASN__CTFAIL(app_key, td, sptr,
 702                         "%s: value not given (%s:%d)",
 703                         td->name, __FILE__, __LINE__);
 704                 return -1;
 705         }
 706
 707
 708         if(1 /* No applicable constraints whatsoever */) {
 709                 /* Nothing is here. See below */
 710         }
 711
 712         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 713 }
 714
 715 static asn_type_selector_result_t
 716 select_RICaction_ToBeSetup_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 717         asn_type_selector_result_t result = {0, 0};
 718         const asn_ioc_set_t *itable = asn_IOS_RICaction_ToBeSetup_ItemIEs_1;
 719         size_t constraining_column = 0; /* &id */
 720         size_t for_column = 2; /* &Value */
 721         size_t row, presence_index = 0;
 722         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_ToBeSetup_ItemIEs, id));
 723
 724         for(row=0; row < itable->rows_count; row++) {
 725             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 726             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 727
 728             if(type_cell->cell_kind == aioc__undefined)
 729                 continue;
 730
 731             presence_index++;
 732             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 733                 result.type_descriptor = type_cell->type_descriptor;
 734                 result.presence_index = presence_index;
 735                 break;
 736             }
 737         }
 738
 739         return result;
 740 }
 741
 742 static int
 743 memb_value_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 744                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 745
 746         if(!sptr) {
 747                 ASN__CTFAIL(app_key, td, sptr,
 748                         "%s: value not given (%s:%d)",
 749                         td->name, __FILE__, __LINE__);
 750                 return -1;
 751         }
 752
 753
 754         if(1 /* No applicable constraints whatsoever */) {
 755                 /* Nothing is here. See below */
 756         }
 757
 758         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 759 }
 760
 761 static int
 762 memb_id_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 763                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 764         long value;
 765
 766         if(!sptr) {
 767                 ASN__CTFAIL(app_key, td, sptr,
 768                         "%s: value not given (%s:%d)",
 769                         td->name, __FILE__, __LINE__);
 770                 return -1;
 771         }
 772
 773         value = *(const long *)sptr;
 774
 775         if((value >= 0 && value <= 65535)) {
 776                 /* Constraint check succeeded */
 777                 return 0;
 778         } else {
 779                 ASN__CTFAIL(app_key, td, sptr,
 780                         "%s: constraint failed (%s:%d)",
 781                         td->name, __FILE__, __LINE__);
 782                 return -1;
 783         }
 784 }
 785
 786 static asn_type_selector_result_t
 787 select_RICaction_Admitted_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 788         asn_type_selector_result_t result = {0, 0};
 789         const asn_ioc_set_t *itable = asn_IOS_RICaction_Admitted_ItemIEs_1;
 790         size_t constraining_column = 0; /* &id */
 791         size_t for_column = 1; /* &criticality */
 792         size_t row, presence_index = 0;
 793         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_Admitted_ItemIEs, id));
 794
 795         for(row=0; row < itable->rows_count; row++) {
 796             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 797             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 798
 799             if(type_cell->cell_kind == aioc__undefined)
 800                 continue;
 801
 802             presence_index++;
 803             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 804                 result.type_descriptor = type_cell->type_descriptor;
 805                 result.presence_index = presence_index;
 806                 break;
 807             }
 808         }
 809
 810         return result;
 811 }
 812
 813 static int
 814 memb_criticality_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 815                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 816
 817         if(!sptr) {
 818                 ASN__CTFAIL(app_key, td, sptr,
 819                         "%s: value not given (%s:%d)",
 820                         td->name, __FILE__, __LINE__);
 821                 return -1;
 822         }
 823
 824
 825         if(1 /* No applicable constraints whatsoever */) {
 826                 /* Nothing is here. See below */
 827         }
 828
 829         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 830 }
 831
 832 static asn_type_selector_result_t
 833 select_RICaction_Admitted_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 834         asn_type_selector_result_t result = {0, 0};
 835         const asn_ioc_set_t *itable = asn_IOS_RICaction_Admitted_ItemIEs_1;
 836         size_t constraining_column = 0; /* &id */
 837         size_t for_column = 2; /* &Value */
 838         size_t row, presence_index = 0;
 839         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_Admitted_ItemIEs, id));
 840
 841         for(row=0; row < itable->rows_count; row++) {
 842             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 843             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 844
 845             if(type_cell->cell_kind == aioc__undefined)
 846                 continue;
 847
 848             presence_index++;
 849             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 850                 result.type_descriptor = type_cell->type_descriptor;
 851                 result.presence_index = presence_index;
 852                 break;
 853             }
 854         }
 855
 856         return result;
 857 }
 858
 859 static int
 860 memb_value_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 861                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 862
 863         if(!sptr) {
 864                 ASN__CTFAIL(app_key, td, sptr,
 865                         "%s: value not given (%s:%d)",
 866                         td->name, __FILE__, __LINE__);
 867                 return -1;
 868         }
 869
 870
 871         if(1 /* No applicable constraints whatsoever */) {
 872                 /* Nothing is here. See below */
 873         }
 874
 875         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 876 }
 877
 878 static int
 879 memb_id_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 880                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 881         long value;
 882
 883         if(!sptr) {
 884                 ASN__CTFAIL(app_key, td, sptr,
 885                         "%s: value not given (%s:%d)",
 886                         td->name, __FILE__, __LINE__);
 887                 return -1;
 888         }
 889
 890         value = *(const long *)sptr;
 891
 892         if((value >= 0 && value <= 65535)) {
 893                 /* Constraint check succeeded */
 894                 return 0;
 895         } else {
 896                 ASN__CTFAIL(app_key, td, sptr,
 897                         "%s: constraint failed (%s:%d)",
 898                         td->name, __FILE__, __LINE__);
 899                 return -1;
 900         }
 901 }
 902
 903 static asn_type_selector_result_t
 904 select_RICaction_NotAdmitted_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 905         asn_type_selector_result_t result = {0, 0};
 906         const asn_ioc_set_t *itable = asn_IOS_RICaction_NotAdmitted_ItemIEs_1;
 907         size_t constraining_column = 0; /* &id */
 908         size_t for_column = 1; /* &criticality */
 909         size_t row, presence_index = 0;
 910         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_NotAdmitted_ItemIEs, id));
 911
 912         for(row=0; row < itable->rows_count; row++) {
 913             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 914             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 915
 916             if(type_cell->cell_kind == aioc__undefined)
 917                 continue;
 918
 919             presence_index++;
 920             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 921                 result.type_descriptor = type_cell->type_descriptor;
 922                 result.presence_index = presence_index;
 923                 break;
 924             }
 925         }
 926
 927         return result;
 928 }
 929
 930 static int
 931 memb_criticality_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 932                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 933
 934         if(!sptr) {
 935                 ASN__CTFAIL(app_key, td, sptr,
 936                         "%s: value not given (%s:%d)",
 937                         td->name, __FILE__, __LINE__);
 938                 return -1;
 939         }
 940
 941
 942         if(1 /* No applicable constraints whatsoever */) {
 943                 /* Nothing is here. See below */
 944         }
 945
 946         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 947 }
 948
 949 static asn_type_selector_result_t
 950 select_RICaction_NotAdmitted_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
 951         asn_type_selector_result_t result = {0, 0};
 952         const asn_ioc_set_t *itable = asn_IOS_RICaction_NotAdmitted_ItemIEs_1;
 953         size_t constraining_column = 0; /* &id */
 954         size_t for_column = 2; /* &Value */
 955         size_t row, presence_index = 0;
 956         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICaction_NotAdmitted_ItemIEs, id));
 957
 958         for(row=0; row < itable->rows_count; row++) {
 959             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
 960             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
 961
 962             if(type_cell->cell_kind == aioc__undefined)
 963                 continue;
 964
 965             presence_index++;
 966             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
 967                 result.type_descriptor = type_cell->type_descriptor;
 968                 result.presence_index = presence_index;
 969                 break;
 970             }
 971         }
 972
 973         return result;
 974 }
 975
 976 static int
 977 memb_value_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 978                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 979
 980         if(!sptr) {
 981                 ASN__CTFAIL(app_key, td, sptr,
 982                         "%s: value not given (%s:%d)",
 983                         td->name, __FILE__, __LINE__);
 984                 return -1;
 985         }
 986
 987
 988         if(1 /* No applicable constraints whatsoever */) {
 989                 /* Nothing is here. See below */
 990         }
 991
 992         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 993 }
 994
 995 static int
 996 memb_id_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
 997                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 998         long value;
 999
1000         if(!sptr) {
1001                 ASN__CTFAIL(app_key, td, sptr,
1002                         "%s: value not given (%s:%d)",
1003                         td->name, __FILE__, __LINE__);
1004                 return -1;
1005         }
1006
1007         value = *(const long *)sptr;
1008
1009         if((value >= 0 && value <= 65535)) {
1010                 /* Constraint check succeeded */
1011                 return 0;
1012         } else {
1013                 ASN__CTFAIL(app_key, td, sptr,
1014                         "%s: constraint failed (%s:%d)",
1015                         td->name, __FILE__, __LINE__);
1016                 return -1;
1017         }
1018 }
1019
1020 static asn_type_selector_result_t
1021 select_RANfunction_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1022         asn_type_selector_result_t result = {0, 0};
1023         const asn_ioc_set_t *itable = asn_IOS_RANfunction_ItemIEs_1;
1024         size_t constraining_column = 0; /* &id */
1025         size_t for_column = 1; /* &criticality */
1026         size_t row, presence_index = 0;
1027         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunction_ItemIEs, id));
1028
1029         for(row=0; row < itable->rows_count; row++) {
1030             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1031             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1032
1033             if(type_cell->cell_kind == aioc__undefined)
1034                 continue;
1035
1036             presence_index++;
1037             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1038                 result.type_descriptor = type_cell->type_descriptor;
1039                 result.presence_index = presence_index;
1040                 break;
1041             }
1042         }
1043
1044         return result;
1045 }
1046
1047 static int
1048 memb_criticality_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
1049                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1050
1051         if(!sptr) {
1052                 ASN__CTFAIL(app_key, td, sptr,
1053                         "%s: value not given (%s:%d)",
1054                         td->name, __FILE__, __LINE__);
1055                 return -1;
1056         }
1057
1058
1059         if(1 /* No applicable constraints whatsoever */) {
1060                 /* Nothing is here. See below */
1061         }
1062
1063         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1064 }
1065
1066 static asn_type_selector_result_t
1067 select_RANfunction_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1068         asn_type_selector_result_t result = {0, 0};
1069         const asn_ioc_set_t *itable = asn_IOS_RANfunction_ItemIEs_1;
1070         size_t constraining_column = 0; /* &id */
1071         size_t for_column = 2; /* &Value */
1072         size_t row, presence_index = 0;
1073         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunction_ItemIEs, id));
1074
1075         for(row=0; row < itable->rows_count; row++) {
1076             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1077             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1078
1079             if(type_cell->cell_kind == aioc__undefined)
1080                 continue;
1081
1082             presence_index++;
1083             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1084                 result.type_descriptor = type_cell->type_descriptor;
1085                 result.presence_index = presence_index;
1086                 break;
1087             }
1088         }
1089
1090         return result;
1091 }
1092
1093 static int
1094 memb_value_constraint_13(const asn_TYPE_descriptor_t *td, const void *sptr,
1095                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1096
1097         if(!sptr) {
1098                 ASN__CTFAIL(app_key, td, sptr,
1099                         "%s: value not given (%s:%d)",
1100                         td->name, __FILE__, __LINE__);
1101                 return -1;
1102         }
1103
1104
1105         if(1 /* No applicable constraints whatsoever */) {
1106                 /* Nothing is here. See below */
1107         }
1108
1109         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1110 }
1111
1112 static int
1113 memb_id_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1114                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1115         long value;
1116
1117         if(!sptr) {
1118                 ASN__CTFAIL(app_key, td, sptr,
1119                         "%s: value not given (%s:%d)",
1120                         td->name, __FILE__, __LINE__);
1121                 return -1;
1122         }
1123
1124         value = *(const long *)sptr;
1125
1126         if((value >= 0 && value <= 65535)) {
1127                 /* Constraint check succeeded */
1128                 return 0;
1129         } else {
1130                 ASN__CTFAIL(app_key, td, sptr,
1131                         "%s: constraint failed (%s:%d)",
1132                         td->name, __FILE__, __LINE__);
1133                 return -1;
1134         }
1135 }
1136
1137 static asn_type_selector_result_t
1138 select_RANfunctionID_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1139         asn_type_selector_result_t result = {0, 0};
1140         const asn_ioc_set_t *itable = asn_IOS_RANfunctionID_ItemIEs_1;
1141         size_t constraining_column = 0; /* &id */
1142         size_t for_column = 1; /* &criticality */
1143         size_t row, presence_index = 0;
1144         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionID_ItemIEs, id));
1145
1146         for(row=0; row < itable->rows_count; row++) {
1147             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1148             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1149
1150             if(type_cell->cell_kind == aioc__undefined)
1151                 continue;
1152
1153             presence_index++;
1154             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1155                 result.type_descriptor = type_cell->type_descriptor;
1156                 result.presence_index = presence_index;
1157                 break;
1158             }
1159         }
1160
1161         return result;
1162 }
1163
1164 static int
1165 memb_criticality_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1166                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1167
1168         if(!sptr) {
1169                 ASN__CTFAIL(app_key, td, sptr,
1170                         "%s: value not given (%s:%d)",
1171                         td->name, __FILE__, __LINE__);
1172                 return -1;
1173         }
1174
1175
1176         if(1 /* No applicable constraints whatsoever */) {
1177                 /* Nothing is here. See below */
1178         }
1179
1180         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1181 }
1182
1183 static asn_type_selector_result_t
1184 select_RANfunctionID_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1185         asn_type_selector_result_t result = {0, 0};
1186         const asn_ioc_set_t *itable = asn_IOS_RANfunctionID_ItemIEs_1;
1187         size_t constraining_column = 0; /* &id */
1188         size_t for_column = 2; /* &Value */
1189         size_t row, presence_index = 0;
1190         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionID_ItemIEs, id));
1191
1192         for(row=0; row < itable->rows_count; row++) {
1193             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1194             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1195
1196             if(type_cell->cell_kind == aioc__undefined)
1197                 continue;
1198
1199             presence_index++;
1200             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1201                 result.type_descriptor = type_cell->type_descriptor;
1202                 result.presence_index = presence_index;
1203                 break;
1204             }
1205         }
1206
1207         return result;
1208 }
1209
1210 static int
1211 memb_value_constraint_17(const asn_TYPE_descriptor_t *td, const void *sptr,
1212                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1213
1214         if(!sptr) {
1215                 ASN__CTFAIL(app_key, td, sptr,
1216                         "%s: value not given (%s:%d)",
1217                         td->name, __FILE__, __LINE__);
1218                 return -1;
1219         }
1220
1221
1222         if(1 /* No applicable constraints whatsoever */) {
1223                 /* Nothing is here. See below */
1224         }
1225
1226         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1227 }
1228
1229 static int
1230 memb_id_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1231                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1232         long value;
1233
1234         if(!sptr) {
1235                 ASN__CTFAIL(app_key, td, sptr,
1236                         "%s: value not given (%s:%d)",
1237                         td->name, __FILE__, __LINE__);
1238                 return -1;
1239         }
1240
1241         value = *(const long *)sptr;
1242
1243         if((value >= 0 && value <= 65535)) {
1244                 /* Constraint check succeeded */
1245                 return 0;
1246         } else {
1247                 ASN__CTFAIL(app_key, td, sptr,
1248                         "%s: constraint failed (%s:%d)",
1249                         td->name, __FILE__, __LINE__);
1250                 return -1;
1251         }
1252 }
1253
1254 static asn_type_selector_result_t
1255 select_RANfunctionIDcause_ItemIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1256         asn_type_selector_result_t result = {0, 0};
1257         const asn_ioc_set_t *itable = asn_IOS_RANfunctionIDcause_ItemIEs_1;
1258         size_t constraining_column = 0; /* &id */
1259         size_t for_column = 1; /* &criticality */
1260         size_t row, presence_index = 0;
1261         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionIDcause_ItemIEs, id));
1262
1263         for(row=0; row < itable->rows_count; row++) {
1264             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1265             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1266
1267             if(type_cell->cell_kind == aioc__undefined)
1268                 continue;
1269
1270             presence_index++;
1271             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1272                 result.type_descriptor = type_cell->type_descriptor;
1273                 result.presence_index = presence_index;
1274                 break;
1275             }
1276         }
1277
1278         return result;
1279 }
1280
1281 static int
1282 memb_criticality_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1283                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1284
1285         if(!sptr) {
1286                 ASN__CTFAIL(app_key, td, sptr,
1287                         "%s: value not given (%s:%d)",
1288                         td->name, __FILE__, __LINE__);
1289                 return -1;
1290         }
1291
1292
1293         if(1 /* No applicable constraints whatsoever */) {
1294                 /* Nothing is here. See below */
1295         }
1296
1297         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1298 }
1299
1300 static asn_type_selector_result_t
1301 select_RANfunctionIDcause_ItemIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1302         asn_type_selector_result_t result = {0, 0};
1303         const asn_ioc_set_t *itable = asn_IOS_RANfunctionIDcause_ItemIEs_1;
1304         size_t constraining_column = 0; /* &id */
1305         size_t for_column = 2; /* &Value */
1306         size_t row, presence_index = 0;
1307         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RANfunctionIDcause_ItemIEs, id));
1308
1309         for(row=0; row < itable->rows_count; row++) {
1310             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1311             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1312
1313             if(type_cell->cell_kind == aioc__undefined)
1314                 continue;
1315
1316             presence_index++;
1317             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1318                 result.type_descriptor = type_cell->type_descriptor;
1319                 result.presence_index = presence_index;
1320                 break;
1321             }
1322         }
1323
1324         return result;
1325 }
1326
1327 static int
1328 memb_value_constraint_21(const asn_TYPE_descriptor_t *td, const void *sptr,
1329                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1330
1331         if(!sptr) {
1332                 ASN__CTFAIL(app_key, td, sptr,
1333                         "%s: value not given (%s:%d)",
1334                         td->name, __FILE__, __LINE__);
1335                 return -1;
1336         }
1337
1338
1339         if(1 /* No applicable constraints whatsoever */) {
1340                 /* Nothing is here. See below */
1341         }
1342
1343         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1344 }
1345
1346 static int
1347 memb_id_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1348                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1349         long value;
1350
1351         if(!sptr) {
1352                 ASN__CTFAIL(app_key, td, sptr,
1353                         "%s: value not given (%s:%d)",
1354                         td->name, __FILE__, __LINE__);
1355                 return -1;
1356         }
1357
1358         value = *(const long *)sptr;
1359
1360         if((value >= 0 && value <= 65535)) {
1361                 /* Constraint check succeeded */
1362                 return 0;
1363         } else {
1364                 ASN__CTFAIL(app_key, td, sptr,
1365                         "%s: constraint failed (%s:%d)",
1366                         td->name, __FILE__, __LINE__);
1367                 return -1;
1368         }
1369 }
1370
1371 static asn_type_selector_result_t
1372 select_RICsubscriptionRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1373         asn_type_selector_result_t result = {0, 0};
1374         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionRequest_IEs_1;
1375         size_t constraining_column = 0; /* &id */
1376         size_t for_column = 1; /* &criticality */
1377         size_t row, presence_index = 0;
1378         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionRequest_IEs, id));
1379
1380         for(row=0; row < itable->rows_count; row++) {
1381             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1382             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1383
1384             if(type_cell->cell_kind == aioc__undefined)
1385                 continue;
1386
1387             presence_index++;
1388             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1389                 result.type_descriptor = type_cell->type_descriptor;
1390                 result.presence_index = presence_index;
1391                 break;
1392             }
1393         }
1394
1395         return result;
1396 }
1397
1398 static int
1399 memb_criticality_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1400                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1401
1402         if(!sptr) {
1403                 ASN__CTFAIL(app_key, td, sptr,
1404                         "%s: value not given (%s:%d)",
1405                         td->name, __FILE__, __LINE__);
1406                 return -1;
1407         }
1408
1409
1410         if(1 /* No applicable constraints whatsoever */) {
1411                 /* Nothing is here. See below */
1412         }
1413
1414         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1415 }
1416
1417 static asn_type_selector_result_t
1418 select_RICsubscriptionRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1419         asn_type_selector_result_t result = {0, 0};
1420         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionRequest_IEs_1;
1421         size_t constraining_column = 0; /* &id */
1422         size_t for_column = 2; /* &Value */
1423         size_t row, presence_index = 0;
1424         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionRequest_IEs, id));
1425
1426         for(row=0; row < itable->rows_count; row++) {
1427             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1428             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1429
1430             if(type_cell->cell_kind == aioc__undefined)
1431                 continue;
1432
1433             presence_index++;
1434             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1435                 result.type_descriptor = type_cell->type_descriptor;
1436                 result.presence_index = presence_index;
1437                 break;
1438             }
1439         }
1440
1441         return result;
1442 }
1443
1444 static int
1445 memb_value_constraint_25(const asn_TYPE_descriptor_t *td, const void *sptr,
1446                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1447
1448         if(!sptr) {
1449                 ASN__CTFAIL(app_key, td, sptr,
1450                         "%s: value not given (%s:%d)",
1451                         td->name, __FILE__, __LINE__);
1452                 return -1;
1453         }
1454
1455
1456         if(1 /* No applicable constraints whatsoever */) {
1457                 /* Nothing is here. See below */
1458         }
1459
1460         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1461 }
1462
1463 static int
1464 memb_id_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1465                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1466         long value;
1467
1468         if(!sptr) {
1469                 ASN__CTFAIL(app_key, td, sptr,
1470                         "%s: value not given (%s:%d)",
1471                         td->name, __FILE__, __LINE__);
1472                 return -1;
1473         }
1474
1475         value = *(const long *)sptr;
1476
1477         if((value >= 0 && value <= 65535)) {
1478                 /* Constraint check succeeded */
1479                 return 0;
1480         } else {
1481                 ASN__CTFAIL(app_key, td, sptr,
1482                         "%s: constraint failed (%s:%d)",
1483                         td->name, __FILE__, __LINE__);
1484                 return -1;
1485         }
1486 }
1487
1488 static asn_type_selector_result_t
1489 select_RICsubscriptionResponse_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1490         asn_type_selector_result_t result = {0, 0};
1491         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionResponse_IEs_1;
1492         size_t constraining_column = 0; /* &id */
1493         size_t for_column = 1; /* &criticality */
1494         size_t row, presence_index = 0;
1495         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionResponse_IEs, id));
1496
1497         for(row=0; row < itable->rows_count; row++) {
1498             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1499             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1500
1501             if(type_cell->cell_kind == aioc__undefined)
1502                 continue;
1503
1504             presence_index++;
1505             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1506                 result.type_descriptor = type_cell->type_descriptor;
1507                 result.presence_index = presence_index;
1508                 break;
1509             }
1510         }
1511
1512         return result;
1513 }
1514
1515 static int
1516 memb_criticality_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1517                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1518
1519         if(!sptr) {
1520                 ASN__CTFAIL(app_key, td, sptr,
1521                         "%s: value not given (%s:%d)",
1522                         td->name, __FILE__, __LINE__);
1523                 return -1;
1524         }
1525
1526
1527         if(1 /* No applicable constraints whatsoever */) {
1528                 /* Nothing is here. See below */
1529         }
1530
1531         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1532 }
1533
1534 static asn_type_selector_result_t
1535 select_RICsubscriptionResponse_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1536         asn_type_selector_result_t result = {0, 0};
1537         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionResponse_IEs_1;
1538         size_t constraining_column = 0; /* &id */
1539         size_t for_column = 2; /* &Value */
1540         size_t row, presence_index = 0;
1541         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionResponse_IEs, id));
1542
1543         for(row=0; row < itable->rows_count; row++) {
1544             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1545             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1546
1547             if(type_cell->cell_kind == aioc__undefined)
1548                 continue;
1549
1550             presence_index++;
1551             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1552                 result.type_descriptor = type_cell->type_descriptor;
1553                 result.presence_index = presence_index;
1554                 break;
1555             }
1556         }
1557
1558         return result;
1559 }
1560
1561 static int
1562 memb_value_constraint_29(const asn_TYPE_descriptor_t *td, const void *sptr,
1563                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1564
1565         if(!sptr) {
1566                 ASN__CTFAIL(app_key, td, sptr,
1567                         "%s: value not given (%s:%d)",
1568                         td->name, __FILE__, __LINE__);
1569                 return -1;
1570         }
1571
1572
1573         if(1 /* No applicable constraints whatsoever */) {
1574                 /* Nothing is here. See below */
1575         }
1576
1577         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1578 }
1579
1580 static int
1581 memb_id_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1582                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1583         long value;
1584
1585         if(!sptr) {
1586                 ASN__CTFAIL(app_key, td, sptr,
1587                         "%s: value not given (%s:%d)",
1588                         td->name, __FILE__, __LINE__);
1589                 return -1;
1590         }
1591
1592         value = *(const long *)sptr;
1593
1594         if((value >= 0 && value <= 65535)) {
1595                 /* Constraint check succeeded */
1596                 return 0;
1597         } else {
1598                 ASN__CTFAIL(app_key, td, sptr,
1599                         "%s: constraint failed (%s:%d)",
1600                         td->name, __FILE__, __LINE__);
1601                 return -1;
1602         }
1603 }
1604
1605 static asn_type_selector_result_t
1606 select_RICsubscriptionFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1607         asn_type_selector_result_t result = {0, 0};
1608         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionFailure_IEs_1;
1609         size_t constraining_column = 0; /* &id */
1610         size_t for_column = 1; /* &criticality */
1611         size_t row, presence_index = 0;
1612         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionFailure_IEs, id));
1613
1614         for(row=0; row < itable->rows_count; row++) {
1615             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1616             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1617
1618             if(type_cell->cell_kind == aioc__undefined)
1619                 continue;
1620
1621             presence_index++;
1622             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1623                 result.type_descriptor = type_cell->type_descriptor;
1624                 result.presence_index = presence_index;
1625                 break;
1626             }
1627         }
1628
1629         return result;
1630 }
1631
1632 static int
1633 memb_criticality_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1634                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1635
1636         if(!sptr) {
1637                 ASN__CTFAIL(app_key, td, sptr,
1638                         "%s: value not given (%s:%d)",
1639                         td->name, __FILE__, __LINE__);
1640                 return -1;
1641         }
1642
1643
1644         if(1 /* No applicable constraints whatsoever */) {
1645                 /* Nothing is here. See below */
1646         }
1647
1648         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1649 }
1650
1651 static asn_type_selector_result_t
1652 select_RICsubscriptionFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1653         asn_type_selector_result_t result = {0, 0};
1654         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionFailure_IEs_1;
1655         size_t constraining_column = 0; /* &id */
1656         size_t for_column = 2; /* &Value */
1657         size_t row, presence_index = 0;
1658         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionFailure_IEs, id));
1659
1660         for(row=0; row < itable->rows_count; row++) {
1661             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1662             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1663
1664             if(type_cell->cell_kind == aioc__undefined)
1665                 continue;
1666
1667             presence_index++;
1668             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1669                 result.type_descriptor = type_cell->type_descriptor;
1670                 result.presence_index = presence_index;
1671                 break;
1672             }
1673         }
1674
1675         return result;
1676 }
1677
1678 static int
1679 memb_value_constraint_33(const asn_TYPE_descriptor_t *td, const void *sptr,
1680                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1681
1682         if(!sptr) {
1683                 ASN__CTFAIL(app_key, td, sptr,
1684                         "%s: value not given (%s:%d)",
1685                         td->name, __FILE__, __LINE__);
1686                 return -1;
1687         }
1688
1689
1690         if(1 /* No applicable constraints whatsoever */) {
1691                 /* Nothing is here. See below */
1692         }
1693
1694         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1695 }
1696
1697 static int
1698 memb_id_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1699                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1700         long value;
1701
1702         if(!sptr) {
1703                 ASN__CTFAIL(app_key, td, sptr,
1704                         "%s: value not given (%s:%d)",
1705                         td->name, __FILE__, __LINE__);
1706                 return -1;
1707         }
1708
1709         value = *(const long *)sptr;
1710
1711         if((value >= 0 && value <= 65535)) {
1712                 /* Constraint check succeeded */
1713                 return 0;
1714         } else {
1715                 ASN__CTFAIL(app_key, td, sptr,
1716                         "%s: constraint failed (%s:%d)",
1717                         td->name, __FILE__, __LINE__);
1718                 return -1;
1719         }
1720 }
1721
1722 static asn_type_selector_result_t
1723 select_RICsubscriptionDeleteRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1724         asn_type_selector_result_t result = {0, 0};
1725         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteRequest_IEs_1;
1726         size_t constraining_column = 0; /* &id */
1727         size_t for_column = 1; /* &criticality */
1728         size_t row, presence_index = 0;
1729         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteRequest_IEs, id));
1730
1731         for(row=0; row < itable->rows_count; row++) {
1732             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1733             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1734
1735             if(type_cell->cell_kind == aioc__undefined)
1736                 continue;
1737
1738             presence_index++;
1739             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1740                 result.type_descriptor = type_cell->type_descriptor;
1741                 result.presence_index = presence_index;
1742                 break;
1743             }
1744         }
1745
1746         return result;
1747 }
1748
1749 static int
1750 memb_criticality_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1751                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1752
1753         if(!sptr) {
1754                 ASN__CTFAIL(app_key, td, sptr,
1755                         "%s: value not given (%s:%d)",
1756                         td->name, __FILE__, __LINE__);
1757                 return -1;
1758         }
1759
1760
1761         if(1 /* No applicable constraints whatsoever */) {
1762                 /* Nothing is here. See below */
1763         }
1764
1765         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1766 }
1767
1768 static asn_type_selector_result_t
1769 select_RICsubscriptionDeleteRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1770         asn_type_selector_result_t result = {0, 0};
1771         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteRequest_IEs_1;
1772         size_t constraining_column = 0; /* &id */
1773         size_t for_column = 2; /* &Value */
1774         size_t row, presence_index = 0;
1775         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteRequest_IEs, id));
1776
1777         for(row=0; row < itable->rows_count; row++) {
1778             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1779             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1780
1781             if(type_cell->cell_kind == aioc__undefined)
1782                 continue;
1783
1784             presence_index++;
1785             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1786                 result.type_descriptor = type_cell->type_descriptor;
1787                 result.presence_index = presence_index;
1788                 break;
1789             }
1790         }
1791
1792         return result;
1793 }
1794
1795 static int
1796 memb_value_constraint_37(const asn_TYPE_descriptor_t *td, const void *sptr,
1797                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1798
1799         if(!sptr) {
1800                 ASN__CTFAIL(app_key, td, sptr,
1801                         "%s: value not given (%s:%d)",
1802                         td->name, __FILE__, __LINE__);
1803                 return -1;
1804         }
1805
1806
1807         if(1 /* No applicable constraints whatsoever */) {
1808                 /* Nothing is here. See below */
1809         }
1810
1811         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1812 }
1813
1814 static int
1815 memb_id_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1816                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1817         long value;
1818
1819         if(!sptr) {
1820                 ASN__CTFAIL(app_key, td, sptr,
1821                         "%s: value not given (%s:%d)",
1822                         td->name, __FILE__, __LINE__);
1823                 return -1;
1824         }
1825
1826         value = *(const long *)sptr;
1827
1828         if((value >= 0 && value <= 65535)) {
1829                 /* Constraint check succeeded */
1830                 return 0;
1831         } else {
1832                 ASN__CTFAIL(app_key, td, sptr,
1833                         "%s: constraint failed (%s:%d)",
1834                         td->name, __FILE__, __LINE__);
1835                 return -1;
1836         }
1837 }
1838
1839 static asn_type_selector_result_t
1840 select_RICsubscriptionDeleteResponse_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1841         asn_type_selector_result_t result = {0, 0};
1842         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteResponse_IEs_1;
1843         size_t constraining_column = 0; /* &id */
1844         size_t for_column = 1; /* &criticality */
1845         size_t row, presence_index = 0;
1846         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteResponse_IEs, id));
1847
1848         for(row=0; row < itable->rows_count; row++) {
1849             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1850             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1851
1852             if(type_cell->cell_kind == aioc__undefined)
1853                 continue;
1854
1855             presence_index++;
1856             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1857                 result.type_descriptor = type_cell->type_descriptor;
1858                 result.presence_index = presence_index;
1859                 break;
1860             }
1861         }
1862
1863         return result;
1864 }
1865
1866 static int
1867 memb_criticality_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1868                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1869
1870         if(!sptr) {
1871                 ASN__CTFAIL(app_key, td, sptr,
1872                         "%s: value not given (%s:%d)",
1873                         td->name, __FILE__, __LINE__);
1874                 return -1;
1875         }
1876
1877
1878         if(1 /* No applicable constraints whatsoever */) {
1879                 /* Nothing is here. See below */
1880         }
1881
1882         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1883 }
1884
1885 static asn_type_selector_result_t
1886 select_RICsubscriptionDeleteResponse_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1887         asn_type_selector_result_t result = {0, 0};
1888         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteResponse_IEs_1;
1889         size_t constraining_column = 0; /* &id */
1890         size_t for_column = 2; /* &Value */
1891         size_t row, presence_index = 0;
1892         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteResponse_IEs, id));
1893
1894         for(row=0; row < itable->rows_count; row++) {
1895             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1896             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1897
1898             if(type_cell->cell_kind == aioc__undefined)
1899                 continue;
1900
1901             presence_index++;
1902             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1903                 result.type_descriptor = type_cell->type_descriptor;
1904                 result.presence_index = presence_index;
1905                 break;
1906             }
1907         }
1908
1909         return result;
1910 }
1911
1912 static int
1913 memb_value_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1914                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1915
1916         if(!sptr) {
1917                 ASN__CTFAIL(app_key, td, sptr,
1918                         "%s: value not given (%s:%d)",
1919                         td->name, __FILE__, __LINE__);
1920                 return -1;
1921         }
1922
1923
1924         if(1 /* No applicable constraints whatsoever */) {
1925                 /* Nothing is here. See below */
1926         }
1927
1928         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
1929 }
1930
1931 static int
1932 memb_id_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
1933                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1934         long value;
1935
1936         if(!sptr) {
1937                 ASN__CTFAIL(app_key, td, sptr,
1938                         "%s: value not given (%s:%d)",
1939                         td->name, __FILE__, __LINE__);
1940                 return -1;
1941         }
1942
1943         value = *(const long *)sptr;
1944
1945         if((value >= 0 && value <= 65535)) {
1946                 /* Constraint check succeeded */
1947                 return 0;
1948         } else {
1949                 ASN__CTFAIL(app_key, td, sptr,
1950                         "%s: constraint failed (%s:%d)",
1951                         td->name, __FILE__, __LINE__);
1952                 return -1;
1953         }
1954 }
1955
1956 static asn_type_selector_result_t
1957 select_RICsubscriptionDeleteFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
1958         asn_type_selector_result_t result = {0, 0};
1959         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteFailure_IEs_1;
1960         size_t constraining_column = 0; /* &id */
1961         size_t for_column = 1; /* &criticality */
1962         size_t row, presence_index = 0;
1963         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteFailure_IEs, id));
1964
1965         for(row=0; row < itable->rows_count; row++) {
1966             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
1967             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
1968
1969             if(type_cell->cell_kind == aioc__undefined)
1970                 continue;
1971
1972             presence_index++;
1973             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
1974                 result.type_descriptor = type_cell->type_descriptor;
1975                 result.presence_index = presence_index;
1976                 break;
1977             }
1978         }
1979
1980         return result;
1981 }
1982
1983 static int
1984 memb_criticality_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
1985                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1986
1987         if(!sptr) {
1988                 ASN__CTFAIL(app_key, td, sptr,
1989                         "%s: value not given (%s:%d)",
1990                         td->name, __FILE__, __LINE__);
1991                 return -1;
1992         }
1993
1994
1995         if(1 /* No applicable constraints whatsoever */) {
1996                 /* Nothing is here. See below */
1997         }
1998
1999         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2000 }
2001
2002 static asn_type_selector_result_t
2003 select_RICsubscriptionDeleteFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2004         asn_type_selector_result_t result = {0, 0};
2005         const asn_ioc_set_t *itable = asn_IOS_RICsubscriptionDeleteFailure_IEs_1;
2006         size_t constraining_column = 0; /* &id */
2007         size_t for_column = 2; /* &Value */
2008         size_t row, presence_index = 0;
2009         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICsubscriptionDeleteFailure_IEs, id));
2010
2011         for(row=0; row < itable->rows_count; row++) {
2012             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2013             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2014
2015             if(type_cell->cell_kind == aioc__undefined)
2016                 continue;
2017
2018             presence_index++;
2019             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2020                 result.type_descriptor = type_cell->type_descriptor;
2021                 result.presence_index = presence_index;
2022                 break;
2023             }
2024         }
2025
2026         return result;
2027 }
2028
2029 static int
2030 memb_value_constraint_45(const asn_TYPE_descriptor_t *td, const void *sptr,
2031                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2032
2033         if(!sptr) {
2034                 ASN__CTFAIL(app_key, td, sptr,
2035                         "%s: value not given (%s:%d)",
2036                         td->name, __FILE__, __LINE__);
2037                 return -1;
2038         }
2039
2040
2041         if(1 /* No applicable constraints whatsoever */) {
2042                 /* Nothing is here. See below */
2043         }
2044
2045         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2046 }
2047
2048 static int
2049 memb_id_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2050                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2051         long value;
2052
2053         if(!sptr) {
2054                 ASN__CTFAIL(app_key, td, sptr,
2055                         "%s: value not given (%s:%d)",
2056                         td->name, __FILE__, __LINE__);
2057                 return -1;
2058         }
2059
2060         value = *(const long *)sptr;
2061
2062         if((value >= 0 && value <= 65535)) {
2063                 /* Constraint check succeeded */
2064                 return 0;
2065         } else {
2066                 ASN__CTFAIL(app_key, td, sptr,
2067                         "%s: constraint failed (%s:%d)",
2068                         td->name, __FILE__, __LINE__);
2069                 return -1;
2070         }
2071 }
2072
2073 static asn_type_selector_result_t
2074 select_RICindication_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2075         asn_type_selector_result_t result = {0, 0};
2076         const asn_ioc_set_t *itable = asn_IOS_RICindication_IEs_1;
2077         size_t constraining_column = 0; /* &id */
2078         size_t for_column = 1; /* &criticality */
2079         size_t row, presence_index = 0;
2080         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICindication_IEs, id));
2081
2082         for(row=0; row < itable->rows_count; row++) {
2083             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2084             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2085
2086             if(type_cell->cell_kind == aioc__undefined)
2087                 continue;
2088
2089             presence_index++;
2090             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2091                 result.type_descriptor = type_cell->type_descriptor;
2092                 result.presence_index = presence_index;
2093                 break;
2094             }
2095         }
2096
2097         return result;
2098 }
2099
2100 static int
2101 memb_criticality_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2102                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2103
2104         if(!sptr) {
2105                 ASN__CTFAIL(app_key, td, sptr,
2106                         "%s: value not given (%s:%d)",
2107                         td->name, __FILE__, __LINE__);
2108                 return -1;
2109         }
2110
2111
2112         if(1 /* No applicable constraints whatsoever */) {
2113                 /* Nothing is here. See below */
2114         }
2115
2116         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2117 }
2118
2119 static asn_type_selector_result_t
2120 select_RICindication_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2121         asn_type_selector_result_t result = {0, 0};
2122         const asn_ioc_set_t *itable = asn_IOS_RICindication_IEs_1;
2123         size_t constraining_column = 0; /* &id */
2124         size_t for_column = 2; /* &Value */
2125         size_t row, presence_index = 0;
2126         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICindication_IEs, id));
2127
2128         for(row=0; row < itable->rows_count; row++) {
2129             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2130             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2131
2132             if(type_cell->cell_kind == aioc__undefined)
2133                 continue;
2134
2135             presence_index++;
2136             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2137                 result.type_descriptor = type_cell->type_descriptor;
2138                 result.presence_index = presence_index;
2139                 break;
2140             }
2141         }
2142
2143         return result;
2144 }
2145
2146 static int
2147 memb_value_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2148                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2149
2150         if(!sptr) {
2151                 ASN__CTFAIL(app_key, td, sptr,
2152                         "%s: value not given (%s:%d)",
2153                         td->name, __FILE__, __LINE__);
2154                 return -1;
2155         }
2156
2157
2158         if(1 /* No applicable constraints whatsoever */) {
2159                 /* Nothing is here. See below */
2160         }
2161
2162         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2163 }
2164
2165 static int
2166 memb_id_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2167                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2168         long value;
2169
2170         if(!sptr) {
2171                 ASN__CTFAIL(app_key, td, sptr,
2172                         "%s: value not given (%s:%d)",
2173                         td->name, __FILE__, __LINE__);
2174                 return -1;
2175         }
2176
2177         value = *(const long *)sptr;
2178
2179         if((value >= 0 && value <= 65535)) {
2180                 /* Constraint check succeeded */
2181                 return 0;
2182         } else {
2183                 ASN__CTFAIL(app_key, td, sptr,
2184                         "%s: constraint failed (%s:%d)",
2185                         td->name, __FILE__, __LINE__);
2186                 return -1;
2187         }
2188 }
2189
2190 static asn_type_selector_result_t
2191 select_RICcontrolRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2192         asn_type_selector_result_t result = {0, 0};
2193         const asn_ioc_set_t *itable = asn_IOS_RICcontrolRequest_IEs_1;
2194         size_t constraining_column = 0; /* &id */
2195         size_t for_column = 1; /* &criticality */
2196         size_t row, presence_index = 0;
2197         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolRequest_IEs, id));
2198
2199         for(row=0; row < itable->rows_count; row++) {
2200             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2201             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2202
2203             if(type_cell->cell_kind == aioc__undefined)
2204                 continue;
2205
2206             presence_index++;
2207             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2208                 result.type_descriptor = type_cell->type_descriptor;
2209                 result.presence_index = presence_index;
2210                 break;
2211             }
2212         }
2213
2214         return result;
2215 }
2216
2217 static int
2218 memb_criticality_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2219                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2220
2221         if(!sptr) {
2222                 ASN__CTFAIL(app_key, td, sptr,
2223                         "%s: value not given (%s:%d)",
2224                         td->name, __FILE__, __LINE__);
2225                 return -1;
2226         }
2227
2228
2229         if(1 /* No applicable constraints whatsoever */) {
2230                 /* Nothing is here. See below */
2231         }
2232
2233         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2234 }
2235
2236 static asn_type_selector_result_t
2237 select_RICcontrolRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2238         asn_type_selector_result_t result = {0, 0};
2239         const asn_ioc_set_t *itable = asn_IOS_RICcontrolRequest_IEs_1;
2240         size_t constraining_column = 0; /* &id */
2241         size_t for_column = 2; /* &Value */
2242         size_t row, presence_index = 0;
2243         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolRequest_IEs, id));
2244
2245         for(row=0; row < itable->rows_count; row++) {
2246             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2247             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2248
2249             if(type_cell->cell_kind == aioc__undefined)
2250                 continue;
2251
2252             presence_index++;
2253             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2254                 result.type_descriptor = type_cell->type_descriptor;
2255                 result.presence_index = presence_index;
2256                 break;
2257             }
2258         }
2259
2260         return result;
2261 }
2262
2263 static int
2264 memb_value_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2265                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2266
2267         if(!sptr) {
2268                 ASN__CTFAIL(app_key, td, sptr,
2269                         "%s: value not given (%s:%d)",
2270                         td->name, __FILE__, __LINE__);
2271                 return -1;
2272         }
2273
2274
2275         if(1 /* No applicable constraints whatsoever */) {
2276                 /* Nothing is here. See below */
2277         }
2278
2279         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2280 }
2281
2282 static int
2283 memb_id_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2284                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2285         long value;
2286
2287         if(!sptr) {
2288                 ASN__CTFAIL(app_key, td, sptr,
2289                         "%s: value not given (%s:%d)",
2290                         td->name, __FILE__, __LINE__);
2291                 return -1;
2292         }
2293
2294         value = *(const long *)sptr;
2295
2296         if((value >= 0 && value <= 65535)) {
2297                 /* Constraint check succeeded */
2298                 return 0;
2299         } else {
2300                 ASN__CTFAIL(app_key, td, sptr,
2301                         "%s: constraint failed (%s:%d)",
2302                         td->name, __FILE__, __LINE__);
2303                 return -1;
2304         }
2305 }
2306
2307 static asn_type_selector_result_t
2308 select_RICcontrolAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2309         asn_type_selector_result_t result = {0, 0};
2310         const asn_ioc_set_t *itable = asn_IOS_RICcontrolAcknowledge_IEs_1;
2311         size_t constraining_column = 0; /* &id */
2312         size_t for_column = 1; /* &criticality */
2313         size_t row, presence_index = 0;
2314         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolAcknowledge_IEs, id));
2315
2316         for(row=0; row < itable->rows_count; row++) {
2317             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2318             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2319
2320             if(type_cell->cell_kind == aioc__undefined)
2321                 continue;
2322
2323             presence_index++;
2324             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2325                 result.type_descriptor = type_cell->type_descriptor;
2326                 result.presence_index = presence_index;
2327                 break;
2328             }
2329         }
2330
2331         return result;
2332 }
2333
2334 static int
2335 memb_criticality_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2336                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2337
2338         if(!sptr) {
2339                 ASN__CTFAIL(app_key, td, sptr,
2340                         "%s: value not given (%s:%d)",
2341                         td->name, __FILE__, __LINE__);
2342                 return -1;
2343         }
2344
2345
2346         if(1 /* No applicable constraints whatsoever */) {
2347                 /* Nothing is here. See below */
2348         }
2349
2350         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2351 }
2352
2353 static asn_type_selector_result_t
2354 select_RICcontrolAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2355         asn_type_selector_result_t result = {0, 0};
2356         const asn_ioc_set_t *itable = asn_IOS_RICcontrolAcknowledge_IEs_1;
2357         size_t constraining_column = 0; /* &id */
2358         size_t for_column = 2; /* &Value */
2359         size_t row, presence_index = 0;
2360         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolAcknowledge_IEs, id));
2361
2362         for(row=0; row < itable->rows_count; row++) {
2363             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2364             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2365
2366             if(type_cell->cell_kind == aioc__undefined)
2367                 continue;
2368
2369             presence_index++;
2370             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2371                 result.type_descriptor = type_cell->type_descriptor;
2372                 result.presence_index = presence_index;
2373                 break;
2374             }
2375         }
2376
2377         return result;
2378 }
2379
2380 static int
2381 memb_value_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2382                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2383
2384         if(!sptr) {
2385                 ASN__CTFAIL(app_key, td, sptr,
2386                         "%s: value not given (%s:%d)",
2387                         td->name, __FILE__, __LINE__);
2388                 return -1;
2389         }
2390
2391
2392         if(1 /* No applicable constraints whatsoever */) {
2393                 /* Nothing is here. See below */
2394         }
2395
2396         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2397 }
2398
2399 static int
2400 memb_id_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2401                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2402         long value;
2403
2404         if(!sptr) {
2405                 ASN__CTFAIL(app_key, td, sptr,
2406                         "%s: value not given (%s:%d)",
2407                         td->name, __FILE__, __LINE__);
2408                 return -1;
2409         }
2410
2411         value = *(const long *)sptr;
2412
2413         if((value >= 0 && value <= 65535)) {
2414                 /* Constraint check succeeded */
2415                 return 0;
2416         } else {
2417                 ASN__CTFAIL(app_key, td, sptr,
2418                         "%s: constraint failed (%s:%d)",
2419                         td->name, __FILE__, __LINE__);
2420                 return -1;
2421         }
2422 }
2423
2424 static asn_type_selector_result_t
2425 select_RICcontrolFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2426         asn_type_selector_result_t result = {0, 0};
2427         const asn_ioc_set_t *itable = asn_IOS_RICcontrolFailure_IEs_1;
2428         size_t constraining_column = 0; /* &id */
2429         size_t for_column = 1; /* &criticality */
2430         size_t row, presence_index = 0;
2431         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolFailure_IEs, id));
2432
2433         for(row=0; row < itable->rows_count; row++) {
2434             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2435             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2436
2437             if(type_cell->cell_kind == aioc__undefined)
2438                 continue;
2439
2440             presence_index++;
2441             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2442                 result.type_descriptor = type_cell->type_descriptor;
2443                 result.presence_index = presence_index;
2444                 break;
2445             }
2446         }
2447
2448         return result;
2449 }
2450
2451 static int
2452 memb_criticality_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2453                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2454
2455         if(!sptr) {
2456                 ASN__CTFAIL(app_key, td, sptr,
2457                         "%s: value not given (%s:%d)",
2458                         td->name, __FILE__, __LINE__);
2459                 return -1;
2460         }
2461
2462
2463         if(1 /* No applicable constraints whatsoever */) {
2464                 /* Nothing is here. See below */
2465         }
2466
2467         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2468 }
2469
2470 static asn_type_selector_result_t
2471 select_RICcontrolFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2472         asn_type_selector_result_t result = {0, 0};
2473         const asn_ioc_set_t *itable = asn_IOS_RICcontrolFailure_IEs_1;
2474         size_t constraining_column = 0; /* &id */
2475         size_t for_column = 2; /* &Value */
2476         size_t row, presence_index = 0;
2477         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolFailure_IEs, id));
2478
2479         for(row=0; row < itable->rows_count; row++) {
2480             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2481             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2482
2483             if(type_cell->cell_kind == aioc__undefined)
2484                 continue;
2485
2486             presence_index++;
2487             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2488                 result.type_descriptor = type_cell->type_descriptor;
2489                 result.presence_index = presence_index;
2490                 break;
2491             }
2492         }
2493
2494         return result;
2495 }
2496
2497 static int
2498 memb_value_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2499                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2500
2501         if(!sptr) {
2502                 ASN__CTFAIL(app_key, td, sptr,
2503                         "%s: value not given (%s:%d)",
2504                         td->name, __FILE__, __LINE__);
2505                 return -1;
2506         }
2507
2508
2509         if(1 /* No applicable constraints whatsoever */) {
2510                 /* Nothing is here. See below */
2511         }
2512
2513         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2514 }
2515
2516 static int
2517 memb_id_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2518                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2519         long value;
2520
2521         if(!sptr) {
2522                 ASN__CTFAIL(app_key, td, sptr,
2523                         "%s: value not given (%s:%d)",
2524                         td->name, __FILE__, __LINE__);
2525                 return -1;
2526         }
2527
2528         value = *(const long *)sptr;
2529
2530         if((value >= 0 && value <= 65535)) {
2531                 /* Constraint check succeeded */
2532                 return 0;
2533         } else {
2534                 ASN__CTFAIL(app_key, td, sptr,
2535                         "%s: constraint failed (%s:%d)",
2536                         td->name, __FILE__, __LINE__);
2537                 return -1;
2538         }
2539 }
2540
2541 static asn_type_selector_result_t
2542 select_ErrorIndication_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2543         asn_type_selector_result_t result = {0, 0};
2544         const asn_ioc_set_t *itable = asn_IOS_ErrorIndication_IEs_1;
2545         size_t constraining_column = 0; /* &id */
2546         size_t for_column = 1; /* &criticality */
2547         size_t row, presence_index = 0;
2548         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ErrorIndication_IEs, id));
2549
2550         for(row=0; row < itable->rows_count; row++) {
2551             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2552             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2553
2554             if(type_cell->cell_kind == aioc__undefined)
2555                 continue;
2556
2557             presence_index++;
2558             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2559                 result.type_descriptor = type_cell->type_descriptor;
2560                 result.presence_index = presence_index;
2561                 break;
2562             }
2563         }
2564
2565         return result;
2566 }
2567
2568 static int
2569 memb_criticality_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2570                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2571
2572         if(!sptr) {
2573                 ASN__CTFAIL(app_key, td, sptr,
2574                         "%s: value not given (%s:%d)",
2575                         td->name, __FILE__, __LINE__);
2576                 return -1;
2577         }
2578
2579
2580         if(1 /* No applicable constraints whatsoever */) {
2581                 /* Nothing is here. See below */
2582         }
2583
2584         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2585 }
2586
2587 static asn_type_selector_result_t
2588 select_ErrorIndication_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2589         asn_type_selector_result_t result = {0, 0};
2590         const asn_ioc_set_t *itable = asn_IOS_ErrorIndication_IEs_1;
2591         size_t constraining_column = 0; /* &id */
2592         size_t for_column = 2; /* &Value */
2593         size_t row, presence_index = 0;
2594         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ErrorIndication_IEs, id));
2595
2596         for(row=0; row < itable->rows_count; row++) {
2597             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2598             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2599
2600             if(type_cell->cell_kind == aioc__undefined)
2601                 continue;
2602
2603             presence_index++;
2604             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2605                 result.type_descriptor = type_cell->type_descriptor;
2606                 result.presence_index = presence_index;
2607                 break;
2608             }
2609         }
2610
2611         return result;
2612 }
2613
2614 static int
2615 memb_value_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2616                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2617
2618         if(!sptr) {
2619                 ASN__CTFAIL(app_key, td, sptr,
2620                         "%s: value not given (%s:%d)",
2621                         td->name, __FILE__, __LINE__);
2622                 return -1;
2623         }
2624
2625
2626         if(1 /* No applicable constraints whatsoever */) {
2627                 /* Nothing is here. See below */
2628         }
2629
2630         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2631 }
2632
2633 static int
2634 memb_id_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2635                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2636         long value;
2637
2638         if(!sptr) {
2639                 ASN__CTFAIL(app_key, td, sptr,
2640                         "%s: value not given (%s:%d)",
2641                         td->name, __FILE__, __LINE__);
2642                 return -1;
2643         }
2644
2645         value = *(const long *)sptr;
2646
2647         if((value >= 0 && value <= 65535)) {
2648                 /* Constraint check succeeded */
2649                 return 0;
2650         } else {
2651                 ASN__CTFAIL(app_key, td, sptr,
2652                         "%s: constraint failed (%s:%d)",
2653                         td->name, __FILE__, __LINE__);
2654                 return -1;
2655         }
2656 }
2657
2658 static asn_type_selector_result_t
2659 select_E2setupRequestIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2660         asn_type_selector_result_t result = {0, 0};
2661         const asn_ioc_set_t *itable = asn_IOS_E2setupRequestIEs_1;
2662         size_t constraining_column = 0; /* &id */
2663         size_t for_column = 1; /* &criticality */
2664         size_t row, presence_index = 0;
2665         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupRequestIEs, id));
2666
2667         for(row=0; row < itable->rows_count; row++) {
2668             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2669             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2670
2671             if(type_cell->cell_kind == aioc__undefined)
2672                 continue;
2673
2674             presence_index++;
2675             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2676                 result.type_descriptor = type_cell->type_descriptor;
2677                 result.presence_index = presence_index;
2678                 break;
2679             }
2680         }
2681
2682         return result;
2683 }
2684
2685 static int
2686 memb_criticality_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2687                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2688
2689         if(!sptr) {
2690                 ASN__CTFAIL(app_key, td, sptr,
2691                         "%s: value not given (%s:%d)",
2692                         td->name, __FILE__, __LINE__);
2693                 return -1;
2694         }
2695
2696
2697         if(1 /* No applicable constraints whatsoever */) {
2698                 /* Nothing is here. See below */
2699         }
2700
2701         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2702 }
2703
2704 static asn_type_selector_result_t
2705 select_E2setupRequestIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2706         asn_type_selector_result_t result = {0, 0};
2707         const asn_ioc_set_t *itable = asn_IOS_E2setupRequestIEs_1;
2708         size_t constraining_column = 0; /* &id */
2709         size_t for_column = 2; /* &Value */
2710         size_t row, presence_index = 0;
2711         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupRequestIEs, id));
2712
2713         for(row=0; row < itable->rows_count; row++) {
2714             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2715             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2716
2717             if(type_cell->cell_kind == aioc__undefined)
2718                 continue;
2719
2720             presence_index++;
2721             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2722                 result.type_descriptor = type_cell->type_descriptor;
2723                 result.presence_index = presence_index;
2724                 break;
2725             }
2726         }
2727
2728         return result;
2729 }
2730
2731 static int
2732 memb_value_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2733                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2734
2735         if(!sptr) {
2736                 ASN__CTFAIL(app_key, td, sptr,
2737                         "%s: value not given (%s:%d)",
2738                         td->name, __FILE__, __LINE__);
2739                 return -1;
2740         }
2741
2742
2743         if(1 /* No applicable constraints whatsoever */) {
2744                 /* Nothing is here. See below */
2745         }
2746
2747         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2748 }
2749
2750 static int
2751 memb_id_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2752                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2753         long value;
2754
2755         if(!sptr) {
2756                 ASN__CTFAIL(app_key, td, sptr,
2757                         "%s: value not given (%s:%d)",
2758                         td->name, __FILE__, __LINE__);
2759                 return -1;
2760         }
2761
2762         value = *(const long *)sptr;
2763
2764         if((value >= 0 && value <= 65535)) {
2765                 /* Constraint check succeeded */
2766                 return 0;
2767         } else {
2768                 ASN__CTFAIL(app_key, td, sptr,
2769                         "%s: constraint failed (%s:%d)",
2770                         td->name, __FILE__, __LINE__);
2771                 return -1;
2772         }
2773 }
2774
2775 static asn_type_selector_result_t
2776 select_E2setupResponseIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2777         asn_type_selector_result_t result = {0, 0};
2778         const asn_ioc_set_t *itable = asn_IOS_E2setupResponseIEs_1;
2779         size_t constraining_column = 0; /* &id */
2780         size_t for_column = 1; /* &criticality */
2781         size_t row, presence_index = 0;
2782         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupResponseIEs, id));
2783
2784         for(row=0; row < itable->rows_count; row++) {
2785             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2786             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2787
2788             if(type_cell->cell_kind == aioc__undefined)
2789                 continue;
2790
2791             presence_index++;
2792             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2793                 result.type_descriptor = type_cell->type_descriptor;
2794                 result.presence_index = presence_index;
2795                 break;
2796             }
2797         }
2798
2799         return result;
2800 }
2801
2802 static int
2803 memb_criticality_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2804                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2805
2806         if(!sptr) {
2807                 ASN__CTFAIL(app_key, td, sptr,
2808                         "%s: value not given (%s:%d)",
2809                         td->name, __FILE__, __LINE__);
2810                 return -1;
2811         }
2812
2813
2814         if(1 /* No applicable constraints whatsoever */) {
2815                 /* Nothing is here. See below */
2816         }
2817
2818         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2819 }
2820
2821 static asn_type_selector_result_t
2822 select_E2setupResponseIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2823         asn_type_selector_result_t result = {0, 0};
2824         const asn_ioc_set_t *itable = asn_IOS_E2setupResponseIEs_1;
2825         size_t constraining_column = 0; /* &id */
2826         size_t for_column = 2; /* &Value */
2827         size_t row, presence_index = 0;
2828         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupResponseIEs, id));
2829
2830         for(row=0; row < itable->rows_count; row++) {
2831             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2832             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2833
2834             if(type_cell->cell_kind == aioc__undefined)
2835                 continue;
2836
2837             presence_index++;
2838             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2839                 result.type_descriptor = type_cell->type_descriptor;
2840                 result.presence_index = presence_index;
2841                 break;
2842             }
2843         }
2844
2845         return result;
2846 }
2847
2848 static int
2849 memb_value_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2850                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2851
2852         if(!sptr) {
2853                 ASN__CTFAIL(app_key, td, sptr,
2854                         "%s: value not given (%s:%d)",
2855                         td->name, __FILE__, __LINE__);
2856                 return -1;
2857         }
2858
2859
2860         if(1 /* No applicable constraints whatsoever */) {
2861                 /* Nothing is here. See below */
2862         }
2863
2864         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2865 }
2866
2867 static int
2868 memb_id_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2869                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2870         long value;
2871
2872         if(!sptr) {
2873                 ASN__CTFAIL(app_key, td, sptr,
2874                         "%s: value not given (%s:%d)",
2875                         td->name, __FILE__, __LINE__);
2876                 return -1;
2877         }
2878
2879         value = *(const long *)sptr;
2880
2881         if((value >= 0 && value <= 65535)) {
2882                 /* Constraint check succeeded */
2883                 return 0;
2884         } else {
2885                 ASN__CTFAIL(app_key, td, sptr,
2886                         "%s: constraint failed (%s:%d)",
2887                         td->name, __FILE__, __LINE__);
2888                 return -1;
2889         }
2890 }
2891
2892 static asn_type_selector_result_t
2893 select_E2setupFailureIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2894         asn_type_selector_result_t result = {0, 0};
2895         const asn_ioc_set_t *itable = asn_IOS_E2setupFailureIEs_1;
2896         size_t constraining_column = 0; /* &id */
2897         size_t for_column = 1; /* &criticality */
2898         size_t row, presence_index = 0;
2899         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupFailureIEs, id));
2900
2901         for(row=0; row < itable->rows_count; row++) {
2902             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2903             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2904
2905             if(type_cell->cell_kind == aioc__undefined)
2906                 continue;
2907
2908             presence_index++;
2909             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2910                 result.type_descriptor = type_cell->type_descriptor;
2911                 result.presence_index = presence_index;
2912                 break;
2913             }
2914         }
2915
2916         return result;
2917 }
2918
2919 static int
2920 memb_criticality_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2921                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2922
2923         if(!sptr) {
2924                 ASN__CTFAIL(app_key, td, sptr,
2925                         "%s: value not given (%s:%d)",
2926                         td->name, __FILE__, __LINE__);
2927                 return -1;
2928         }
2929
2930
2931         if(1 /* No applicable constraints whatsoever */) {
2932                 /* Nothing is here. See below */
2933         }
2934
2935         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2936 }
2937
2938 static asn_type_selector_result_t
2939 select_E2setupFailureIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2940         asn_type_selector_result_t result = {0, 0};
2941         const asn_ioc_set_t *itable = asn_IOS_E2setupFailureIEs_1;
2942         size_t constraining_column = 0; /* &id */
2943         size_t for_column = 2; /* &Value */
2944         size_t row, presence_index = 0;
2945         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupFailureIEs, id));
2946
2947         for(row=0; row < itable->rows_count; row++) {
2948             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2949             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2950
2951             if(type_cell->cell_kind == aioc__undefined)
2952                 continue;
2953
2954             presence_index++;
2955             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2956                 result.type_descriptor = type_cell->type_descriptor;
2957                 result.presence_index = presence_index;
2958                 break;
2959             }
2960         }
2961
2962         return result;
2963 }
2964
2965 static int
2966 memb_value_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2967                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2968
2969         if(!sptr) {
2970                 ASN__CTFAIL(app_key, td, sptr,
2971                         "%s: value not given (%s:%d)",
2972                         td->name, __FILE__, __LINE__);
2973                 return -1;
2974         }
2975
2976
2977         if(1 /* No applicable constraints whatsoever */) {
2978                 /* Nothing is here. See below */
2979         }
2980
2981         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2982 }
2983
2984 static int
2985 memb_id_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
2986                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2987         long value;
2988
2989         if(!sptr) {
2990                 ASN__CTFAIL(app_key, td, sptr,
2991                         "%s: value not given (%s:%d)",
2992                         td->name, __FILE__, __LINE__);
2993                 return -1;
2994         }
2995
2996         value = *(const long *)sptr;
2997
2998         if((value >= 0 && value <= 65535)) {
2999                 /* Constraint check succeeded */
3000                 return 0;
3001         } else {
3002                 ASN__CTFAIL(app_key, td, sptr,
3003                         "%s: constraint failed (%s:%d)",
3004                         td->name, __FILE__, __LINE__);
3005                 return -1;
3006         }
3007 }
3008
3009 static asn_type_selector_result_t
3010 select_ResetRequestIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3011         asn_type_selector_result_t result = {0, 0};
3012         const asn_ioc_set_t *itable = asn_IOS_ResetRequestIEs_1;
3013         size_t constraining_column = 0; /* &id */
3014         size_t for_column = 1; /* &criticality */
3015         size_t row, presence_index = 0;
3016         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetRequestIEs, id));
3017
3018         for(row=0; row < itable->rows_count; row++) {
3019             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3020             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3021
3022             if(type_cell->cell_kind == aioc__undefined)
3023                 continue;
3024
3025             presence_index++;
3026             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3027                 result.type_descriptor = type_cell->type_descriptor;
3028                 result.presence_index = presence_index;
3029                 break;
3030             }
3031         }
3032
3033         return result;
3034 }
3035
3036 static int
3037 memb_criticality_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3038                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3039
3040         if(!sptr) {
3041                 ASN__CTFAIL(app_key, td, sptr,
3042                         "%s: value not given (%s:%d)",
3043                         td->name, __FILE__, __LINE__);
3044                 return -1;
3045         }
3046
3047
3048         if(1 /* No applicable constraints whatsoever */) {
3049                 /* Nothing is here. See below */
3050         }
3051
3052         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3053 }
3054
3055 static asn_type_selector_result_t
3056 select_ResetRequestIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3057         asn_type_selector_result_t result = {0, 0};
3058         const asn_ioc_set_t *itable = asn_IOS_ResetRequestIEs_1;
3059         size_t constraining_column = 0; /* &id */
3060         size_t for_column = 2; /* &Value */
3061         size_t row, presence_index = 0;
3062         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetRequestIEs, id));
3063
3064         for(row=0; row < itable->rows_count; row++) {
3065             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3066             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3067
3068             if(type_cell->cell_kind == aioc__undefined)
3069                 continue;
3070
3071             presence_index++;
3072             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3073                 result.type_descriptor = type_cell->type_descriptor;
3074                 result.presence_index = presence_index;
3075                 break;
3076             }
3077         }
3078
3079         return result;
3080 }
3081
3082 static int
3083 memb_value_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3084                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3085
3086         if(!sptr) {
3087                 ASN__CTFAIL(app_key, td, sptr,
3088                         "%s: value not given (%s:%d)",
3089                         td->name, __FILE__, __LINE__);
3090                 return -1;
3091         }
3092
3093
3094         if(1 /* No applicable constraints whatsoever */) {
3095                 /* Nothing is here. See below */
3096         }
3097
3098         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3099 }
3100
3101 static int
3102 memb_id_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3103                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3104         long value;
3105
3106         if(!sptr) {
3107                 ASN__CTFAIL(app_key, td, sptr,
3108                         "%s: value not given (%s:%d)",
3109                         td->name, __FILE__, __LINE__);
3110                 return -1;
3111         }
3112
3113         value = *(const long *)sptr;
3114
3115         if((value >= 0 && value <= 65535)) {
3116                 /* Constraint check succeeded */
3117                 return 0;
3118         } else {
3119                 ASN__CTFAIL(app_key, td, sptr,
3120                         "%s: constraint failed (%s:%d)",
3121                         td->name, __FILE__, __LINE__);
3122                 return -1;
3123         }
3124 }
3125
3126 static asn_type_selector_result_t
3127 select_ResetResponseIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3128         asn_type_selector_result_t result = {0, 0};
3129         const asn_ioc_set_t *itable = asn_IOS_ResetResponseIEs_1;
3130         size_t constraining_column = 0; /* &id */
3131         size_t for_column = 1; /* &criticality */
3132         size_t row, presence_index = 0;
3133         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetResponseIEs, id));
3134
3135         for(row=0; row < itable->rows_count; row++) {
3136             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3137             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3138
3139             if(type_cell->cell_kind == aioc__undefined)
3140                 continue;
3141
3142             presence_index++;
3143             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3144                 result.type_descriptor = type_cell->type_descriptor;
3145                 result.presence_index = presence_index;
3146                 break;
3147             }
3148         }
3149
3150         return result;
3151 }
3152
3153 static int
3154 memb_criticality_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3155                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3156
3157         if(!sptr) {
3158                 ASN__CTFAIL(app_key, td, sptr,
3159                         "%s: value not given (%s:%d)",
3160                         td->name, __FILE__, __LINE__);
3161                 return -1;
3162         }
3163
3164
3165         if(1 /* No applicable constraints whatsoever */) {
3166                 /* Nothing is here. See below */
3167         }
3168
3169         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3170 }
3171
3172 static asn_type_selector_result_t
3173 select_ResetResponseIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3174         asn_type_selector_result_t result = {0, 0};
3175         const asn_ioc_set_t *itable = asn_IOS_ResetResponseIEs_1;
3176         size_t constraining_column = 0; /* &id */
3177         size_t for_column = 2; /* &Value */
3178         size_t row, presence_index = 0;
3179         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetResponseIEs, id));
3180
3181         for(row=0; row < itable->rows_count; row++) {
3182             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3183             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3184
3185             if(type_cell->cell_kind == aioc__undefined)
3186                 continue;
3187
3188             presence_index++;
3189             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3190                 result.type_descriptor = type_cell->type_descriptor;
3191                 result.presence_index = presence_index;
3192                 break;
3193             }
3194         }
3195
3196         return result;
3197 }
3198
3199 static int
3200 memb_value_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3201                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3202
3203         if(!sptr) {
3204                 ASN__CTFAIL(app_key, td, sptr,
3205                         "%s: value not given (%s:%d)",
3206                         td->name, __FILE__, __LINE__);
3207                 return -1;
3208         }
3209
3210
3211         if(1 /* No applicable constraints whatsoever */) {
3212                 /* Nothing is here. See below */
3213         }
3214
3215         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3216 }
3217
3218 static int
3219 memb_id_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3220                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3221         long value;
3222
3223         if(!sptr) {
3224                 ASN__CTFAIL(app_key, td, sptr,
3225                         "%s: value not given (%s:%d)",
3226                         td->name, __FILE__, __LINE__);
3227                 return -1;
3228         }
3229
3230         value = *(const long *)sptr;
3231
3232         if((value >= 0 && value <= 65535)) {
3233                 /* Constraint check succeeded */
3234                 return 0;
3235         } else {
3236                 ASN__CTFAIL(app_key, td, sptr,
3237                         "%s: constraint failed (%s:%d)",
3238                         td->name, __FILE__, __LINE__);
3239                 return -1;
3240         }
3241 }
3242
3243 static asn_type_selector_result_t
3244 select_RICserviceUpdate_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3245         asn_type_selector_result_t result = {0, 0};
3246         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdate_IEs_1;
3247         size_t constraining_column = 0; /* &id */
3248         size_t for_column = 1; /* &criticality */
3249         size_t row, presence_index = 0;
3250         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdate_IEs, id));
3251
3252         for(row=0; row < itable->rows_count; row++) {
3253             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3254             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3255
3256             if(type_cell->cell_kind == aioc__undefined)
3257                 continue;
3258
3259             presence_index++;
3260             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3261                 result.type_descriptor = type_cell->type_descriptor;
3262                 result.presence_index = presence_index;
3263                 break;
3264             }
3265         }
3266
3267         return result;
3268 }
3269
3270 static int
3271 memb_criticality_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3272                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3273
3274         if(!sptr) {
3275                 ASN__CTFAIL(app_key, td, sptr,
3276                         "%s: value not given (%s:%d)",
3277                         td->name, __FILE__, __LINE__);
3278                 return -1;
3279         }
3280
3281
3282         if(1 /* No applicable constraints whatsoever */) {
3283                 /* Nothing is here. See below */
3284         }
3285
3286         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3287 }
3288
3289 static asn_type_selector_result_t
3290 select_RICserviceUpdate_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3291         asn_type_selector_result_t result = {0, 0};
3292         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdate_IEs_1;
3293         size_t constraining_column = 0; /* &id */
3294         size_t for_column = 2; /* &Value */
3295         size_t row, presence_index = 0;
3296         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdate_IEs, id));
3297
3298         for(row=0; row < itable->rows_count; row++) {
3299             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3300             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3301
3302             if(type_cell->cell_kind == aioc__undefined)
3303                 continue;
3304
3305             presence_index++;
3306             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3307                 result.type_descriptor = type_cell->type_descriptor;
3308                 result.presence_index = presence_index;
3309                 break;
3310             }
3311         }
3312
3313         return result;
3314 }
3315
3316 static int
3317 memb_value_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3318                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3319
3320         if(!sptr) {
3321                 ASN__CTFAIL(app_key, td, sptr,
3322                         "%s: value not given (%s:%d)",
3323                         td->name, __FILE__, __LINE__);
3324                 return -1;
3325         }
3326
3327
3328         if(1 /* No applicable constraints whatsoever */) {
3329                 /* Nothing is here. See below */
3330         }
3331
3332         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3333 }
3334
3335 static int
3336 memb_id_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3337                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3338         long value;
3339
3340         if(!sptr) {
3341                 ASN__CTFAIL(app_key, td, sptr,
3342                         "%s: value not given (%s:%d)",
3343                         td->name, __FILE__, __LINE__);
3344                 return -1;
3345         }
3346
3347         value = *(const long *)sptr;
3348
3349         if((value >= 0 && value <= 65535)) {
3350                 /* Constraint check succeeded */
3351                 return 0;
3352         } else {
3353                 ASN__CTFAIL(app_key, td, sptr,
3354                         "%s: constraint failed (%s:%d)",
3355                         td->name, __FILE__, __LINE__);
3356                 return -1;
3357         }
3358 }
3359
3360 static asn_type_selector_result_t
3361 select_RICserviceUpdateAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3362         asn_type_selector_result_t result = {0, 0};
3363         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateAcknowledge_IEs_1;
3364         size_t constraining_column = 0; /* &id */
3365         size_t for_column = 1; /* &criticality */
3366         size_t row, presence_index = 0;
3367         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateAcknowledge_IEs, id));
3368
3369         for(row=0; row < itable->rows_count; row++) {
3370             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3371             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3372
3373             if(type_cell->cell_kind == aioc__undefined)
3374                 continue;
3375
3376             presence_index++;
3377             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3378                 result.type_descriptor = type_cell->type_descriptor;
3379                 result.presence_index = presence_index;
3380                 break;
3381             }
3382         }
3383
3384         return result;
3385 }
3386
3387 static int
3388 memb_criticality_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3389                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3390
3391         if(!sptr) {
3392                 ASN__CTFAIL(app_key, td, sptr,
3393                         "%s: value not given (%s:%d)",
3394                         td->name, __FILE__, __LINE__);
3395                 return -1;
3396         }
3397
3398
3399         if(1 /* No applicable constraints whatsoever */) {
3400                 /* Nothing is here. See below */
3401         }
3402
3403         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3404 }
3405
3406 static asn_type_selector_result_t
3407 select_RICserviceUpdateAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3408         asn_type_selector_result_t result = {0, 0};
3409         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateAcknowledge_IEs_1;
3410         size_t constraining_column = 0; /* &id */
3411         size_t for_column = 2; /* &Value */
3412         size_t row, presence_index = 0;
3413         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateAcknowledge_IEs, id));
3414
3415         for(row=0; row < itable->rows_count; row++) {
3416             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3417             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3418
3419             if(type_cell->cell_kind == aioc__undefined)
3420                 continue;
3421
3422             presence_index++;
3423             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3424                 result.type_descriptor = type_cell->type_descriptor;
3425                 result.presence_index = presence_index;
3426                 break;
3427             }
3428         }
3429
3430         return result;
3431 }
3432
3433 static int
3434 memb_value_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3435                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3436
3437         if(!sptr) {
3438                 ASN__CTFAIL(app_key, td, sptr,
3439                         "%s: value not given (%s:%d)",
3440                         td->name, __FILE__, __LINE__);
3441                 return -1;
3442         }
3443
3444
3445         if(1 /* No applicable constraints whatsoever */) {
3446                 /* Nothing is here. See below */
3447         }
3448
3449         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3450 }
3451
3452 static int
3453 memb_id_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3454                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3455         long value;
3456
3457         if(!sptr) {
3458                 ASN__CTFAIL(app_key, td, sptr,
3459                         "%s: value not given (%s:%d)",
3460                         td->name, __FILE__, __LINE__);
3461                 return -1;
3462         }
3463
3464         value = *(const long *)sptr;
3465
3466         if((value >= 0 && value <= 65535)) {
3467                 /* Constraint check succeeded */
3468                 return 0;
3469         } else {
3470                 ASN__CTFAIL(app_key, td, sptr,
3471                         "%s: constraint failed (%s:%d)",
3472                         td->name, __FILE__, __LINE__);
3473                 return -1;
3474         }
3475 }
3476
3477 static asn_type_selector_result_t
3478 select_RICserviceUpdateFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3479         asn_type_selector_result_t result = {0, 0};
3480         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateFailure_IEs_1;
3481         size_t constraining_column = 0; /* &id */
3482         size_t for_column = 1; /* &criticality */
3483         size_t row, presence_index = 0;
3484         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateFailure_IEs, id));
3485
3486         for(row=0; row < itable->rows_count; row++) {
3487             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3488             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3489
3490             if(type_cell->cell_kind == aioc__undefined)
3491                 continue;
3492
3493             presence_index++;
3494             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3495                 result.type_descriptor = type_cell->type_descriptor;
3496                 result.presence_index = presence_index;
3497                 break;
3498             }
3499         }
3500
3501         return result;
3502 }
3503
3504 static int
3505 memb_criticality_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3506                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3507
3508         if(!sptr) {
3509                 ASN__CTFAIL(app_key, td, sptr,
3510                         "%s: value not given (%s:%d)",
3511                         td->name, __FILE__, __LINE__);
3512                 return -1;
3513         }
3514
3515
3516         if(1 /* No applicable constraints whatsoever */) {
3517                 /* Nothing is here. See below */
3518         }
3519
3520         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3521 }
3522
3523 static asn_type_selector_result_t
3524 select_RICserviceUpdateFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3525         asn_type_selector_result_t result = {0, 0};
3526         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateFailure_IEs_1;
3527         size_t constraining_column = 0; /* &id */
3528         size_t for_column = 2; /* &Value */
3529         size_t row, presence_index = 0;
3530         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateFailure_IEs, id));
3531
3532         for(row=0; row < itable->rows_count; row++) {
3533             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3534             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3535
3536             if(type_cell->cell_kind == aioc__undefined)
3537                 continue;
3538
3539             presence_index++;
3540             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3541                 result.type_descriptor = type_cell->type_descriptor;
3542                 result.presence_index = presence_index;
3543                 break;
3544             }
3545         }
3546
3547         return result;
3548 }
3549
3550 static int
3551 memb_value_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3552                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3553
3554         if(!sptr) {
3555                 ASN__CTFAIL(app_key, td, sptr,
3556                         "%s: value not given (%s:%d)",
3557                         td->name, __FILE__, __LINE__);
3558                 return -1;
3559         }
3560
3561
3562         if(1 /* No applicable constraints whatsoever */) {
3563                 /* Nothing is here. See below */
3564         }
3565
3566         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3567 }
3568
3569 static int
3570 memb_id_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3571                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3572         long value;
3573
3574         if(!sptr) {
3575                 ASN__CTFAIL(app_key, td, sptr,
3576                         "%s: value not given (%s:%d)",
3577                         td->name, __FILE__, __LINE__);
3578                 return -1;
3579         }
3580
3581         value = *(const long *)sptr;
3582
3583         if((value >= 0 && value <= 65535)) {
3584                 /* Constraint check succeeded */
3585                 return 0;
3586         } else {
3587                 ASN__CTFAIL(app_key, td, sptr,
3588                         "%s: constraint failed (%s:%d)",
3589                         td->name, __FILE__, __LINE__);
3590                 return -1;
3591         }
3592 }
3593
3594 static asn_type_selector_result_t
3595 select_RICserviceQuery_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3596         asn_type_selector_result_t result = {0, 0};
3597         const asn_ioc_set_t *itable = asn_IOS_RICserviceQuery_IEs_1;
3598         size_t constraining_column = 0; /* &id */
3599         size_t for_column = 1; /* &criticality */
3600         size_t row, presence_index = 0;
3601         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceQuery_IEs, id));
3602
3603         for(row=0; row < itable->rows_count; row++) {
3604             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3605             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3606
3607             if(type_cell->cell_kind == aioc__undefined)
3608                 continue;
3609
3610             presence_index++;
3611             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3612                 result.type_descriptor = type_cell->type_descriptor;
3613                 result.presence_index = presence_index;
3614                 break;
3615             }
3616         }
3617
3618         return result;
3619 }
3620
3621 static int
3622 memb_criticality_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3623                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3624
3625         if(!sptr) {
3626                 ASN__CTFAIL(app_key, td, sptr,
3627                         "%s: value not given (%s:%d)",
3628                         td->name, __FILE__, __LINE__);
3629                 return -1;
3630         }
3631
3632
3633         if(1 /* No applicable constraints whatsoever */) {
3634                 /* Nothing is here. See below */
3635         }
3636
3637         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3638 }
3639
3640 static asn_type_selector_result_t
3641 select_RICserviceQuery_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3642         asn_type_selector_result_t result = {0, 0};
3643         const asn_ioc_set_t *itable = asn_IOS_RICserviceQuery_IEs_1;
3644         size_t constraining_column = 0; /* &id */
3645         size_t for_column = 2; /* &Value */
3646         size_t row, presence_index = 0;
3647         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceQuery_IEs, id));
3648
3649         for(row=0; row < itable->rows_count; row++) {
3650             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3651             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3652
3653             if(type_cell->cell_kind == aioc__undefined)
3654                 continue;
3655
3656             presence_index++;
3657             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3658                 result.type_descriptor = type_cell->type_descriptor;
3659                 result.presence_index = presence_index;
3660                 break;
3661             }
3662         }
3663
3664         return result;
3665 }
3666
3667 static int
3668 memb_value_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3669                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3670
3671         if(!sptr) {
3672                 ASN__CTFAIL(app_key, td, sptr,
3673                         "%s: value not given (%s:%d)",
3674                         td->name, __FILE__, __LINE__);
3675                 return -1;
3676         }
3677
3678
3679         if(1 /* No applicable constraints whatsoever */) {
3680                 /* Nothing is here. See below */
3681         }
3682
3683         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3684 }
3685
3686 static asn_oer_constraints_t asn_OER_memb_id_constr_2 CC_NOTUSED = {
3687         { 2, 1 }        /* (0..65535) */,
3688         -1};
3689 static asn_per_constraints_t asn_PER_memb_id_constr_2 CC_NOTUSED = {
3690         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3691         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3692         0, 0    /* No PER value map */
3693 };
3694 static asn_oer_constraints_t asn_OER_memb_criticality_constr_3 CC_NOTUSED = {
3695         { 0, 0 },
3696         -1};
3697 static asn_per_constraints_t asn_PER_memb_criticality_constr_3 CC_NOTUSED = {
3698         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3699         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3700         0, 0    /* No PER value map */
3701 };
3702 static asn_oer_constraints_t asn_OER_memb_value_constr_4 CC_NOTUSED = {
3703         { 0, 0 },
3704         -1};
3705 static asn_per_constraints_t asn_PER_memb_value_constr_4 CC_NOTUSED = {
3706         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3707         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3708         0, 0    /* No PER value map */
3709 };
3710 static asn_oer_constraints_t asn_OER_memb_id_constr_6 CC_NOTUSED = {
3711         { 2, 1 }        /* (0..65535) */,
3712         -1};
3713 static asn_per_constraints_t asn_PER_memb_id_constr_6 CC_NOTUSED = {
3714         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3715         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3716         0, 0    /* No PER value map */
3717 };
3718 static asn_oer_constraints_t asn_OER_memb_criticality_constr_7 CC_NOTUSED = {
3719         { 0, 0 },
3720         -1};
3721 static asn_per_constraints_t asn_PER_memb_criticality_constr_7 CC_NOTUSED = {
3722         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3723         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3724         0, 0    /* No PER value map */
3725 };
3726 static asn_oer_constraints_t asn_OER_memb_value_constr_8 CC_NOTUSED = {
3727         { 0, 0 },
3728         -1};
3729 static asn_per_constraints_t asn_PER_memb_value_constr_8 CC_NOTUSED = {
3730         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3731         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3732         0, 0    /* No PER value map */
3733 };
3734 static asn_oer_constraints_t asn_OER_memb_id_constr_10 CC_NOTUSED = {
3735         { 2, 1 }        /* (0..65535) */,
3736         -1};
3737 static asn_per_constraints_t asn_PER_memb_id_constr_10 CC_NOTUSED = {
3738         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3739         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3740         0, 0    /* No PER value map */
3741 };
3742 static asn_oer_constraints_t asn_OER_memb_criticality_constr_11 CC_NOTUSED = {
3743         { 0, 0 },
3744         -1};
3745 static asn_per_constraints_t asn_PER_memb_criticality_constr_11 CC_NOTUSED = {
3746         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3747         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3748         0, 0    /* No PER value map */
3749 };
3750 static asn_oer_constraints_t asn_OER_memb_value_constr_12 CC_NOTUSED = {
3751         { 0, 0 },
3752         -1};
3753 static asn_per_constraints_t asn_PER_memb_value_constr_12 CC_NOTUSED = {
3754         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3755         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3756         0, 0    /* No PER value map */
3757 };
3758 static asn_oer_constraints_t asn_OER_memb_id_constr_14 CC_NOTUSED = {
3759         { 2, 1 }        /* (0..65535) */,
3760         -1};
3761 static asn_per_constraints_t asn_PER_memb_id_constr_14 CC_NOTUSED = {
3762         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3763         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3764         0, 0    /* No PER value map */
3765 };
3766 static asn_oer_constraints_t asn_OER_memb_criticality_constr_15 CC_NOTUSED = {
3767         { 0, 0 },
3768         -1};
3769 static asn_per_constraints_t asn_PER_memb_criticality_constr_15 CC_NOTUSED = {
3770         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3771         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3772         0, 0    /* No PER value map */
3773 };
3774 static asn_oer_constraints_t asn_OER_memb_value_constr_16 CC_NOTUSED = {
3775         { 0, 0 },
3776         -1};
3777 static asn_per_constraints_t asn_PER_memb_value_constr_16 CC_NOTUSED = {
3778         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3779         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3780         0, 0    /* No PER value map */
3781 };
3782 static asn_oer_constraints_t asn_OER_memb_id_constr_18 CC_NOTUSED = {
3783         { 2, 1 }        /* (0..65535) */,
3784         -1};
3785 static asn_per_constraints_t asn_PER_memb_id_constr_18 CC_NOTUSED = {
3786         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3787         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3788         0, 0    /* No PER value map */
3789 };
3790 static asn_oer_constraints_t asn_OER_memb_criticality_constr_19 CC_NOTUSED = {
3791         { 0, 0 },
3792         -1};
3793 static asn_per_constraints_t asn_PER_memb_criticality_constr_19 CC_NOTUSED = {
3794         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3795         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3796         0, 0    /* No PER value map */
3797 };
3798 static asn_oer_constraints_t asn_OER_memb_value_constr_20 CC_NOTUSED = {
3799         { 0, 0 },
3800         -1};
3801 static asn_per_constraints_t asn_PER_memb_value_constr_20 CC_NOTUSED = {
3802         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3803         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3804         0, 0    /* No PER value map */
3805 };
3806 static asn_oer_constraints_t asn_OER_memb_id_constr_22 CC_NOTUSED = {
3807         { 2, 1 }        /* (0..65535) */,
3808         -1};
3809 static asn_per_constraints_t asn_PER_memb_id_constr_22 CC_NOTUSED = {
3810         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3811         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3812         0, 0    /* No PER value map */
3813 };
3814 static asn_oer_constraints_t asn_OER_memb_criticality_constr_23 CC_NOTUSED = {
3815         { 0, 0 },
3816         -1};
3817 static asn_per_constraints_t asn_PER_memb_criticality_constr_23 CC_NOTUSED = {
3818         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3819         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3820         0, 0    /* No PER value map */
3821 };
3822 static asn_oer_constraints_t asn_OER_memb_value_constr_24 CC_NOTUSED = {
3823         { 0, 0 },
3824         -1};
3825 static asn_per_constraints_t asn_PER_memb_value_constr_24 CC_NOTUSED = {
3826         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3827         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3828         0, 0    /* No PER value map */
3829 };
3830 static asn_oer_constraints_t asn_OER_memb_id_constr_26 CC_NOTUSED = {
3831         { 2, 1 }        /* (0..65535) */,
3832         -1};
3833 static asn_per_constraints_t asn_PER_memb_id_constr_26 CC_NOTUSED = {
3834         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3835         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3836         0, 0    /* No PER value map */
3837 };
3838 static asn_oer_constraints_t asn_OER_memb_criticality_constr_27 CC_NOTUSED = {
3839         { 0, 0 },
3840         -1};
3841 static asn_per_constraints_t asn_PER_memb_criticality_constr_27 CC_NOTUSED = {
3842         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3843         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3844         0, 0    /* No PER value map */
3845 };
3846 static asn_oer_constraints_t asn_OER_memb_value_constr_28 CC_NOTUSED = {
3847         { 0, 0 },
3848         -1};
3849 static asn_per_constraints_t asn_PER_memb_value_constr_28 CC_NOTUSED = {
3850         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3851         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3852         0, 0    /* No PER value map */
3853 };
3854 static asn_oer_constraints_t asn_OER_memb_id_constr_30 CC_NOTUSED = {
3855         { 2, 1 }        /* (0..65535) */,
3856         -1};
3857 static asn_per_constraints_t asn_PER_memb_id_constr_30 CC_NOTUSED = {
3858         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3859         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3860         0, 0    /* No PER value map */
3861 };
3862 static asn_oer_constraints_t asn_OER_memb_criticality_constr_31 CC_NOTUSED = {
3863         { 0, 0 },
3864         -1};
3865 static asn_per_constraints_t asn_PER_memb_criticality_constr_31 CC_NOTUSED = {
3866         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3867         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3868         0, 0    /* No PER value map */
3869 };
3870 static asn_oer_constraints_t asn_OER_memb_value_constr_32 CC_NOTUSED = {
3871         { 0, 0 },
3872         -1};
3873 static asn_per_constraints_t asn_PER_memb_value_constr_32 CC_NOTUSED = {
3874         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3875         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3876         0, 0    /* No PER value map */
3877 };
3878 static asn_oer_constraints_t asn_OER_memb_id_constr_34 CC_NOTUSED = {
3879         { 2, 1 }        /* (0..65535) */,
3880         -1};
3881 static asn_per_constraints_t asn_PER_memb_id_constr_34 CC_NOTUSED = {
3882         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3883         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3884         0, 0    /* No PER value map */
3885 };
3886 static asn_oer_constraints_t asn_OER_memb_criticality_constr_35 CC_NOTUSED = {
3887         { 0, 0 },
3888         -1};
3889 static asn_per_constraints_t asn_PER_memb_criticality_constr_35 CC_NOTUSED = {
3890         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3891         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3892         0, 0    /* No PER value map */
3893 };
3894 static asn_oer_constraints_t asn_OER_memb_value_constr_36 CC_NOTUSED = {
3895         { 0, 0 },
3896         -1};
3897 static asn_per_constraints_t asn_PER_memb_value_constr_36 CC_NOTUSED = {
3898         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3899         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3900         0, 0    /* No PER value map */
3901 };
3902 static asn_oer_constraints_t asn_OER_memb_id_constr_38 CC_NOTUSED = {
3903         { 2, 1 }        /* (0..65535) */,
3904         -1};
3905 static asn_per_constraints_t asn_PER_memb_id_constr_38 CC_NOTUSED = {
3906         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3907         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3908         0, 0    /* No PER value map */
3909 };
3910 static asn_oer_constraints_t asn_OER_memb_criticality_constr_39 CC_NOTUSED = {
3911         { 0, 0 },
3912         -1};
3913 static asn_per_constraints_t asn_PER_memb_criticality_constr_39 CC_NOTUSED = {
3914         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3915         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3916         0, 0    /* No PER value map */
3917 };
3918 static asn_oer_constraints_t asn_OER_memb_value_constr_40 CC_NOTUSED = {
3919         { 0, 0 },
3920         -1};
3921 static asn_per_constraints_t asn_PER_memb_value_constr_40 CC_NOTUSED = {
3922         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3923         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3924         0, 0    /* No PER value map */
3925 };
3926 static asn_oer_constraints_t asn_OER_memb_id_constr_42 CC_NOTUSED = {
3927         { 2, 1 }        /* (0..65535) */,
3928         -1};
3929 static asn_per_constraints_t asn_PER_memb_id_constr_42 CC_NOTUSED = {
3930         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3931         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3932         0, 0    /* No PER value map */
3933 };
3934 static asn_oer_constraints_t asn_OER_memb_criticality_constr_43 CC_NOTUSED = {
3935         { 0, 0 },
3936         -1};
3937 static asn_per_constraints_t asn_PER_memb_criticality_constr_43 CC_NOTUSED = {
3938         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3939         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3940         0, 0    /* No PER value map */
3941 };
3942 static asn_oer_constraints_t asn_OER_memb_value_constr_44 CC_NOTUSED = {
3943         { 0, 0 },
3944         -1};
3945 static asn_per_constraints_t asn_PER_memb_value_constr_44 CC_NOTUSED = {
3946         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3947         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3948         0, 0    /* No PER value map */
3949 };
3950 static asn_oer_constraints_t asn_OER_memb_id_constr_46 CC_NOTUSED = {
3951         { 2, 1 }        /* (0..65535) */,
3952         -1};
3953 static asn_per_constraints_t asn_PER_memb_id_constr_46 CC_NOTUSED = {
3954         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3955         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3956         0, 0    /* No PER value map */
3957 };
3958 static asn_oer_constraints_t asn_OER_memb_criticality_constr_47 CC_NOTUSED = {
3959         { 0, 0 },
3960         -1};
3961 static asn_per_constraints_t asn_PER_memb_criticality_constr_47 CC_NOTUSED = {
3962         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3963         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3964         0, 0    /* No PER value map */
3965 };
3966 static asn_oer_constraints_t asn_OER_memb_value_constr_48 CC_NOTUSED = {
3967         { 0, 0 },
3968         -1};
3969 static asn_per_constraints_t asn_PER_memb_value_constr_48 CC_NOTUSED = {
3970         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3971         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3972         0, 0    /* No PER value map */
3973 };
3974 static asn_oer_constraints_t asn_OER_memb_id_constr_50 CC_NOTUSED = {
3975         { 2, 1 }        /* (0..65535) */,
3976         -1};
3977 static asn_per_constraints_t asn_PER_memb_id_constr_50 CC_NOTUSED = {
3978         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3979         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3980         0, 0    /* No PER value map */
3981 };
3982 static asn_oer_constraints_t asn_OER_memb_criticality_constr_51 CC_NOTUSED = {
3983         { 0, 0 },
3984         -1};
3985 static asn_per_constraints_t asn_PER_memb_criticality_constr_51 CC_NOTUSED = {
3986         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3987         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3988         0, 0    /* No PER value map */
3989 };
3990 static asn_oer_constraints_t asn_OER_memb_value_constr_52 CC_NOTUSED = {
3991         { 0, 0 },
3992         -1};
3993 static asn_per_constraints_t asn_PER_memb_value_constr_52 CC_NOTUSED = {
3994         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3995         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3996         0, 0    /* No PER value map */
3997 };
3998 static asn_oer_constraints_t asn_OER_memb_id_constr_54 CC_NOTUSED = {
3999         { 2, 1 }        /* (0..65535) */,
4000         -1};
4001 static asn_per_constraints_t asn_PER_memb_id_constr_54 CC_NOTUSED = {
4002         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4003         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4004         0, 0    /* No PER value map */
4005 };
4006 static asn_oer_constraints_t asn_OER_memb_criticality_constr_55 CC_NOTUSED = {
4007         { 0, 0 },
4008         -1};
4009 static asn_per_constraints_t asn_PER_memb_criticality_constr_55 CC_NOTUSED = {
4010         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4011         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4012         0, 0    /* No PER value map */
4013 };
4014 static asn_oer_constraints_t asn_OER_memb_value_constr_56 CC_NOTUSED = {
4015         { 0, 0 },
4016         -1};
4017 static asn_per_constraints_t asn_PER_memb_value_constr_56 CC_NOTUSED = {
4018         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4019         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4020         0, 0    /* No PER value map */
4021 };
4022 static asn_oer_constraints_t asn_OER_memb_id_constr_58 CC_NOTUSED = {
4023         { 2, 1 }        /* (0..65535) */,
4024         -1};
4025 static asn_per_constraints_t asn_PER_memb_id_constr_58 CC_NOTUSED = {
4026         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4027         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4028         0, 0    /* No PER value map */
4029 };
4030 static asn_oer_constraints_t asn_OER_memb_criticality_constr_59 CC_NOTUSED = {
4031         { 0, 0 },
4032         -1};
4033 static asn_per_constraints_t asn_PER_memb_criticality_constr_59 CC_NOTUSED = {
4034         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4035         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4036         0, 0    /* No PER value map */
4037 };
4038 static asn_oer_constraints_t asn_OER_memb_value_constr_60 CC_NOTUSED = {
4039         { 0, 0 },
4040         -1};
4041 static asn_per_constraints_t asn_PER_memb_value_constr_60 CC_NOTUSED = {
4042         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4043         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4044         0, 0    /* No PER value map */
4045 };
4046 static asn_oer_constraints_t asn_OER_memb_id_constr_62 CC_NOTUSED = {
4047         { 2, 1 }        /* (0..65535) */,
4048         -1};
4049 static asn_per_constraints_t asn_PER_memb_id_constr_62 CC_NOTUSED = {
4050         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4051         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4052         0, 0    /* No PER value map */
4053 };
4054 static asn_oer_constraints_t asn_OER_memb_criticality_constr_63 CC_NOTUSED = {
4055         { 0, 0 },
4056         -1};
4057 static asn_per_constraints_t asn_PER_memb_criticality_constr_63 CC_NOTUSED = {
4058         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4059         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4060         0, 0    /* No PER value map */
4061 };
4062 static asn_oer_constraints_t asn_OER_memb_value_constr_64 CC_NOTUSED = {
4063         { 0, 0 },
4064         -1};
4065 static asn_per_constraints_t asn_PER_memb_value_constr_64 CC_NOTUSED = {
4066         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4067         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4068         0, 0    /* No PER value map */
4069 };
4070 static asn_oer_constraints_t asn_OER_memb_id_constr_66 CC_NOTUSED = {
4071         { 2, 1 }        /* (0..65535) */,
4072         -1};
4073 static asn_per_constraints_t asn_PER_memb_id_constr_66 CC_NOTUSED = {
4074         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4075         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4076         0, 0    /* No PER value map */
4077 };
4078 static asn_oer_constraints_t asn_OER_memb_criticality_constr_67 CC_NOTUSED = {
4079         { 0, 0 },
4080         -1};
4081 static asn_per_constraints_t asn_PER_memb_criticality_constr_67 CC_NOTUSED = {
4082         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4083         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4084         0, 0    /* No PER value map */
4085 };
4086 static asn_oer_constraints_t asn_OER_memb_value_constr_68 CC_NOTUSED = {
4087         { 0, 0 },
4088         -1};
4089 static asn_per_constraints_t asn_PER_memb_value_constr_68 CC_NOTUSED = {
4090         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4091         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4092         0, 0    /* No PER value map */
4093 };
4094 static asn_oer_constraints_t asn_OER_memb_id_constr_70 CC_NOTUSED = {
4095         { 2, 1 }        /* (0..65535) */,
4096         -1};
4097 static asn_per_constraints_t asn_PER_memb_id_constr_70 CC_NOTUSED = {
4098         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4099         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4100         0, 0    /* No PER value map */
4101 };
4102 static asn_oer_constraints_t asn_OER_memb_criticality_constr_71 CC_NOTUSED = {
4103         { 0, 0 },
4104         -1};
4105 static asn_per_constraints_t asn_PER_memb_criticality_constr_71 CC_NOTUSED = {
4106         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4107         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4108         0, 0    /* No PER value map */
4109 };
4110 static asn_oer_constraints_t asn_OER_memb_value_constr_72 CC_NOTUSED = {
4111         { 0, 0 },
4112         -1};
4113 static asn_per_constraints_t asn_PER_memb_value_constr_72 CC_NOTUSED = {
4114         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4115         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4116         0, 0    /* No PER value map */
4117 };
4118 static asn_oer_constraints_t asn_OER_memb_id_constr_74 CC_NOTUSED = {
4119         { 2, 1 }        /* (0..65535) */,
4120         -1};
4121 static asn_per_constraints_t asn_PER_memb_id_constr_74 CC_NOTUSED = {
4122         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4123         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4124         0, 0    /* No PER value map */
4125 };
4126 static asn_oer_constraints_t asn_OER_memb_criticality_constr_75 CC_NOTUSED = {
4127         { 0, 0 },
4128         -1};
4129 static asn_per_constraints_t asn_PER_memb_criticality_constr_75 CC_NOTUSED = {
4130         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4131         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4132         0, 0    /* No PER value map */
4133 };
4134 static asn_oer_constraints_t asn_OER_memb_value_constr_76 CC_NOTUSED = {
4135         { 0, 0 },
4136         -1};
4137 static asn_per_constraints_t asn_PER_memb_value_constr_76 CC_NOTUSED = {
4138         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4139         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4140         0, 0    /* No PER value map */
4141 };
4142 static asn_oer_constraints_t asn_OER_memb_id_constr_78 CC_NOTUSED = {
4143         { 2, 1 }        /* (0..65535) */,
4144         -1};
4145 static asn_per_constraints_t asn_PER_memb_id_constr_78 CC_NOTUSED = {
4146         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4147         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4148         0, 0    /* No PER value map */
4149 };
4150 static asn_oer_constraints_t asn_OER_memb_criticality_constr_79 CC_NOTUSED = {
4151         { 0, 0 },
4152         -1};
4153 static asn_per_constraints_t asn_PER_memb_criticality_constr_79 CC_NOTUSED = {
4154         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4155         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4156         0, 0    /* No PER value map */
4157 };
4158 static asn_oer_constraints_t asn_OER_memb_value_constr_80 CC_NOTUSED = {
4159         { 0, 0 },
4160         -1};
4161 static asn_per_constraints_t asn_PER_memb_value_constr_80 CC_NOTUSED = {
4162         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4163         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4164         0, 0    /* No PER value map */
4165 };
4166 static asn_oer_constraints_t asn_OER_memb_id_constr_82 CC_NOTUSED = {
4167         { 2, 1 }        /* (0..65535) */,
4168         -1};
4169 static asn_per_constraints_t asn_PER_memb_id_constr_82 CC_NOTUSED = {
4170         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4171         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4172         0, 0    /* No PER value map */
4173 };
4174 static asn_oer_constraints_t asn_OER_memb_criticality_constr_83 CC_NOTUSED = {
4175         { 0, 0 },
4176         -1};
4177 static asn_per_constraints_t asn_PER_memb_criticality_constr_83 CC_NOTUSED = {
4178         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4179         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4180         0, 0    /* No PER value map */
4181 };
4182 static asn_oer_constraints_t asn_OER_memb_value_constr_84 CC_NOTUSED = {
4183         { 0, 0 },
4184         -1};
4185 static asn_per_constraints_t asn_PER_memb_value_constr_84 CC_NOTUSED = {
4186         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4187         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4188         0, 0    /* No PER value map */
4189 };
4190 static asn_oer_constraints_t asn_OER_memb_id_constr_86 CC_NOTUSED = {
4191         { 2, 1 }        /* (0..65535) */,
4192         -1};
4193 static asn_per_constraints_t asn_PER_memb_id_constr_86 CC_NOTUSED = {
4194         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4195         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4196         0, 0    /* No PER value map */
4197 };
4198 static asn_oer_constraints_t asn_OER_memb_criticality_constr_87 CC_NOTUSED = {
4199         { 0, 0 },
4200         -1};
4201 static asn_per_constraints_t asn_PER_memb_criticality_constr_87 CC_NOTUSED = {
4202         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4203         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4204         0, 0    /* No PER value map */
4205 };
4206 static asn_oer_constraints_t asn_OER_memb_value_constr_88 CC_NOTUSED = {
4207         { 0, 0 },
4208         -1};
4209 static asn_per_constraints_t asn_PER_memb_value_constr_88 CC_NOTUSED = {
4210         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4211         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4212         0, 0    /* No PER value map */
4213 };
4214 static asn_oer_constraints_t asn_OER_memb_id_constr_90 CC_NOTUSED = {
4215         { 2, 1 }        /* (0..65535) */,
4216         -1};
4217 static asn_per_constraints_t asn_PER_memb_id_constr_90 CC_NOTUSED = {
4218         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4219         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4220         0, 0    /* No PER value map */
4221 };
4222 static asn_oer_constraints_t asn_OER_memb_criticality_constr_91 CC_NOTUSED = {
4223         { 0, 0 },
4224         -1};
4225 static asn_per_constraints_t asn_PER_memb_criticality_constr_91 CC_NOTUSED = {
4226         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4227         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4228         0, 0    /* No PER value map */
4229 };
4230 static asn_oer_constraints_t asn_OER_memb_value_constr_92 CC_NOTUSED = {
4231         { 0, 0 },
4232         -1};
4233 static asn_per_constraints_t asn_PER_memb_value_constr_92 CC_NOTUSED = {
4234         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4235         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4236         0, 0    /* No PER value map */
4237 };
4238 static asn_oer_constraints_t asn_OER_memb_id_constr_94 CC_NOTUSED = {
4239         { 2, 1 }        /* (0..65535) */,
4240         -1};
4241 static asn_per_constraints_t asn_PER_memb_id_constr_94 CC_NOTUSED = {
4242         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4243         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4244         0, 0    /* No PER value map */
4245 };
4246 static asn_oer_constraints_t asn_OER_memb_criticality_constr_95 CC_NOTUSED = {
4247         { 0, 0 },
4248         -1};
4249 static asn_per_constraints_t asn_PER_memb_criticality_constr_95 CC_NOTUSED = {
4250         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4251         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4252         0, 0    /* No PER value map */
4253 };
4254 static asn_oer_constraints_t asn_OER_memb_value_constr_96 CC_NOTUSED = {
4255         { 0, 0 },
4256         -1};
4257 static asn_per_constraints_t asn_PER_memb_value_constr_96 CC_NOTUSED = {
4258         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4259         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4260         0, 0    /* No PER value map */
4261 };
4262 static asn_oer_constraints_t asn_OER_memb_id_constr_98 CC_NOTUSED = {
4263         { 2, 1 }        /* (0..65535) */,
4264         -1};
4265 static asn_per_constraints_t asn_PER_memb_id_constr_98 CC_NOTUSED = {
4266         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4267         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4268         0, 0    /* No PER value map */
4269 };
4270 static asn_oer_constraints_t asn_OER_memb_criticality_constr_99 CC_NOTUSED = {
4271         { 0, 0 },
4272         -1};
4273 static asn_per_constraints_t asn_PER_memb_criticality_constr_99 CC_NOTUSED = {
4274         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4275         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4276         0, 0    /* No PER value map */
4277 };
4278 static asn_oer_constraints_t asn_OER_memb_value_constr_100 CC_NOTUSED = {
4279         { 0, 0 },
4280         -1};
4281 static asn_per_constraints_t asn_PER_memb_value_constr_100 CC_NOTUSED = {
4282         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4283         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4284         0, 0    /* No PER value map */
4285 };
4286 static asn_oer_constraints_t asn_OER_memb_id_constr_102 CC_NOTUSED = {
4287         { 2, 1 }        /* (0..65535) */,
4288         -1};
4289 static asn_per_constraints_t asn_PER_memb_id_constr_102 CC_NOTUSED = {
4290         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4291         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4292         0, 0    /* No PER value map */
4293 };
4294 static asn_oer_constraints_t asn_OER_memb_criticality_constr_103 CC_NOTUSED = {
4295         { 0, 0 },
4296         -1};
4297 static asn_per_constraints_t asn_PER_memb_criticality_constr_103 CC_NOTUSED = {
4298         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4299         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4300         0, 0    /* No PER value map */
4301 };
4302 static asn_oer_constraints_t asn_OER_memb_value_constr_104 CC_NOTUSED = {
4303         { 0, 0 },
4304         -1};
4305 static asn_per_constraints_t asn_PER_memb_value_constr_104 CC_NOTUSED = {
4306         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4307         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4308         0, 0    /* No PER value map */
4309 };
4310 static asn_TYPE_member_t asn_MBR_value_4[] = {
4311         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs__value, choice.RICaction_ToBeSetup_Item),
4312                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4313                 0,
4314                 &asn_DEF_RICaction_ToBeSetup_Item,
4315                 0,
4316                 { 0, 0, 0 },
4317                 0, 0, /* No default value */
4318                 "RICaction-ToBeSetup-Item"
4319                 },
4320 };
4321 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_4[] = {
4322     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-ToBeSetup-Item */
4323 };
4324 static asn_CHOICE_specifics_t asn_SPC_value_specs_4 = {
4325         sizeof(struct RICaction_ToBeSetup_ItemIEs__value),
4326         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, _asn_ctx),
4327         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, present),
4328         sizeof(((struct RICaction_ToBeSetup_ItemIEs__value *)0)->present),
4329         asn_MAP_value_tag2el_4,
4330         1,      /* Count of tags in the map */
4331         0, 0,
4332         -1      /* Extensions start */
4333 };
4334 static /* Use -fall-defs-global to expose */
4335 asn_TYPE_descriptor_t asn_DEF_value_4 = {
4336         "value",
4337         "value",
4338         &asn_OP_OPEN_TYPE,
4339         0,      /* No effective tags (pointer) */
4340         0,      /* No effective tags (count) */
4341         0,      /* No tags (pointer) */
4342         0,      /* No tags (count) */
4343         { 0, 0, OPEN_TYPE_constraint },
4344         asn_MBR_value_4,
4345         1,      /* Elements count */
4346         &asn_SPC_value_specs_4  /* Additional specs */
4347 };
4348
4349 asn_TYPE_member_t asn_MBR_RICaction_ToBeSetup_ItemIEs_1[] = {
4350         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, id),
4351                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4352                 0,
4353                 &asn_DEF_ProtocolIE_ID,
4354                 0,
4355                 { &asn_OER_memb_id_constr_2, &asn_PER_memb_id_constr_2,  memb_id_constraint_1 },
4356                 0, 0, /* No default value */
4357                 "id"
4358                 },
4359         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, criticality),
4360                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4361                 0,
4362                 &asn_DEF_Criticality,
4363                 select_RICaction_ToBeSetup_ItemIEs_criticality_type,
4364                 { &asn_OER_memb_criticality_constr_3, &asn_PER_memb_criticality_constr_3,  memb_criticality_constraint_1 },
4365                 0, 0, /* No default value */
4366                 "criticality"
4367                 },
4368         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, value),
4369                 -1 /* Ambiguous tag (ANY?) */,
4370                 0,
4371                 &asn_DEF_value_4,
4372                 select_RICaction_ToBeSetup_ItemIEs_value_type,
4373                 { &asn_OER_memb_value_constr_4, &asn_PER_memb_value_constr_4,  memb_value_constraint_1 },
4374                 0, 0, /* No default value */
4375                 "value"
4376                 },
4377 };
4378 static const ber_tlv_tag_t asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[] = {
4379         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4380 };
4381 static const asn_TYPE_tag2member_t asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1[] = {
4382     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
4383     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
4384 };
4385 asn_SEQUENCE_specifics_t asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1 = {
4386         sizeof(struct RICaction_ToBeSetup_ItemIEs),
4387         offsetof(struct RICaction_ToBeSetup_ItemIEs, _asn_ctx),
4388         asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1,
4389         2,      /* Count of tags in the map */
4390         0, 0, 0,        /* Optional elements (not needed) */
4391         -1,     /* First extension addition */
4392 };
4393 asn_TYPE_descriptor_t asn_DEF_RICaction_ToBeSetup_ItemIEs = {
4394         "RICaction-ToBeSetup-ItemIEs",
4395         "RICaction-ToBeSetup-ItemIEs",
4396         &asn_OP_SEQUENCE,
4397         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,
4398         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
4399                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
4400         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,     /* Same as above */
4401         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
4402                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
4403         { 0, 0, SEQUENCE_constraint },
4404         asn_MBR_RICaction_ToBeSetup_ItemIEs_1,
4405         3,      /* Elements count */
4406         &asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1    /* Additional specs */
4407 };
4408
4409 static asn_TYPE_member_t asn_MBR_value_8[] = {
4410         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs__value, choice.RICaction_Admitted_Item),
4411                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4412                 0,
4413                 &asn_DEF_RICaction_Admitted_Item,
4414                 0,
4415                 { 0, 0, 0 },
4416                 0, 0, /* No default value */
4417                 "RICaction-Admitted-Item"
4418                 },
4419 };
4420 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_8[] = {
4421     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-Admitted-Item */
4422 };
4423 static asn_CHOICE_specifics_t asn_SPC_value_specs_8 = {
4424         sizeof(struct RICaction_Admitted_ItemIEs__value),
4425         offsetof(struct RICaction_Admitted_ItemIEs__value, _asn_ctx),
4426         offsetof(struct RICaction_Admitted_ItemIEs__value, present),
4427         sizeof(((struct RICaction_Admitted_ItemIEs__value *)0)->present),
4428         asn_MAP_value_tag2el_8,
4429         1,      /* Count of tags in the map */
4430         0, 0,
4431         -1      /* Extensions start */
4432 };
4433 static /* Use -fall-defs-global to expose */
4434 asn_TYPE_descriptor_t asn_DEF_value_8 = {
4435         "value",
4436         "value",
4437         &asn_OP_OPEN_TYPE,
4438         0,      /* No effective tags (pointer) */
4439         0,      /* No effective tags (count) */
4440         0,      /* No tags (pointer) */
4441         0,      /* No tags (count) */
4442         { 0, 0, OPEN_TYPE_constraint },
4443         asn_MBR_value_8,
4444         1,      /* Elements count */
4445         &asn_SPC_value_specs_8  /* Additional specs */
4446 };
4447
4448 asn_TYPE_member_t asn_MBR_RICaction_Admitted_ItemIEs_5[] = {
4449         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, id),
4450                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4451                 0,
4452                 &asn_DEF_ProtocolIE_ID,
4453                 0,
4454                 { &asn_OER_memb_id_constr_6, &asn_PER_memb_id_constr_6,  memb_id_constraint_5 },
4455                 0, 0, /* No default value */
4456                 "id"
4457                 },
4458         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, criticality),
4459                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4460                 0,
4461                 &asn_DEF_Criticality,
4462                 select_RICaction_Admitted_ItemIEs_criticality_type,
4463                 { &asn_OER_memb_criticality_constr_7, &asn_PER_memb_criticality_constr_7,  memb_criticality_constraint_5 },
4464                 0, 0, /* No default value */
4465                 "criticality"
4466                 },
4467         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, value),
4468                 -1 /* Ambiguous tag (ANY?) */,
4469                 0,
4470                 &asn_DEF_value_8,
4471                 select_RICaction_Admitted_ItemIEs_value_type,
4472                 { &asn_OER_memb_value_constr_8, &asn_PER_memb_value_constr_8,  memb_value_constraint_5 },
4473                 0, 0, /* No default value */
4474                 "value"
4475                 },
4476 };
4477 static const ber_tlv_tag_t asn_DEF_RICaction_Admitted_ItemIEs_tags_5[] = {
4478         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4479 };
4480 static const asn_TYPE_tag2member_t asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5[] = {
4481     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
4482     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
4483 };
4484 asn_SEQUENCE_specifics_t asn_SPC_RICaction_Admitted_ItemIEs_specs_5 = {
4485         sizeof(struct RICaction_Admitted_ItemIEs),
4486         offsetof(struct RICaction_Admitted_ItemIEs, _asn_ctx),
4487         asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5,
4488         2,      /* Count of tags in the map */
4489         0, 0, 0,        /* Optional elements (not needed) */
4490         -1,     /* First extension addition */
4491 };
4492 asn_TYPE_descriptor_t asn_DEF_RICaction_Admitted_ItemIEs = {
4493         "RICaction-Admitted-ItemIEs",
4494         "RICaction-Admitted-ItemIEs",
4495         &asn_OP_SEQUENCE,
4496         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,
4497         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
4498                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
4499         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,      /* Same as above */
4500         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
4501                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
4502         { 0, 0, SEQUENCE_constraint },
4503         asn_MBR_RICaction_Admitted_ItemIEs_5,
4504         3,      /* Elements count */
4505         &asn_SPC_RICaction_Admitted_ItemIEs_specs_5     /* Additional specs */
4506 };
4507
4508 static asn_TYPE_member_t asn_MBR_value_12[] = {
4509         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs__value, choice.RICaction_NotAdmitted_Item),
4510                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4511                 0,
4512                 &asn_DEF_RICaction_NotAdmitted_Item,
4513                 0,
4514                 { 0, 0, 0 },
4515                 0, 0, /* No default value */
4516                 "RICaction-NotAdmitted-Item"
4517                 },
4518 };
4519 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_12[] = {
4520     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-NotAdmitted-Item */
4521 };
4522 static asn_CHOICE_specifics_t asn_SPC_value_specs_12 = {
4523         sizeof(struct RICaction_NotAdmitted_ItemIEs__value),
4524         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, _asn_ctx),
4525         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, present),
4526         sizeof(((struct RICaction_NotAdmitted_ItemIEs__value *)0)->present),
4527         asn_MAP_value_tag2el_12,
4528         1,      /* Count of tags in the map */
4529         0, 0,
4530         -1      /* Extensions start */
4531 };
4532 static /* Use -fall-defs-global to expose */
4533 asn_TYPE_descriptor_t asn_DEF_value_12 = {
4534         "value",
4535         "value",
4536         &asn_OP_OPEN_TYPE,
4537         0,      /* No effective tags (pointer) */
4538         0,      /* No effective tags (count) */
4539         0,      /* No tags (pointer) */
4540         0,      /* No tags (count) */
4541         { 0, 0, OPEN_TYPE_constraint },
4542         asn_MBR_value_12,
4543         1,      /* Elements count */
4544         &asn_SPC_value_specs_12 /* Additional specs */
4545 };
4546
4547 asn_TYPE_member_t asn_MBR_RICaction_NotAdmitted_ItemIEs_9[] = {
4548         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, id),
4549                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4550                 0,
4551                 &asn_DEF_ProtocolIE_ID,
4552                 0,
4553                 { &asn_OER_memb_id_constr_10, &asn_PER_memb_id_constr_10,  memb_id_constraint_9 },
4554                 0, 0, /* No default value */
4555                 "id"
4556                 },
4557         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, criticality),
4558                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4559                 0,
4560                 &asn_DEF_Criticality,
4561                 select_RICaction_NotAdmitted_ItemIEs_criticality_type,
4562                 { &asn_OER_memb_criticality_constr_11, &asn_PER_memb_criticality_constr_11,  memb_criticality_constraint_9 },
4563                 0, 0, /* No default value */
4564                 "criticality"
4565                 },
4566         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, value),
4567                 -1 /* Ambiguous tag (ANY?) */,
4568                 0,
4569                 &asn_DEF_value_12,
4570                 select_RICaction_NotAdmitted_ItemIEs_value_type,
4571                 { &asn_OER_memb_value_constr_12, &asn_PER_memb_value_constr_12,  memb_value_constraint_9 },
4572                 0, 0, /* No default value */
4573                 "value"
4574                 },
4575 };
4576 static const ber_tlv_tag_t asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[] = {
4577         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4578 };
4579 static const asn_TYPE_tag2member_t asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9[] = {
4580     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
4581     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
4582 };
4583 asn_SEQUENCE_specifics_t asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9 = {
4584         sizeof(struct RICaction_NotAdmitted_ItemIEs),
4585         offsetof(struct RICaction_NotAdmitted_ItemIEs, _asn_ctx),
4586         asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9,
4587         2,      /* Count of tags in the map */
4588         0, 0, 0,        /* Optional elements (not needed) */
4589         -1,     /* First extension addition */
4590 };
4591 asn_TYPE_descriptor_t asn_DEF_RICaction_NotAdmitted_ItemIEs = {
4592         "RICaction-NotAdmitted-ItemIEs",
4593         "RICaction-NotAdmitted-ItemIEs",
4594         &asn_OP_SEQUENCE,
4595         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,
4596         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
4597                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
4598         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,   /* Same as above */
4599         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
4600                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
4601         { 0, 0, SEQUENCE_constraint },
4602         asn_MBR_RICaction_NotAdmitted_ItemIEs_9,
4603         3,      /* Elements count */
4604         &asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9  /* Additional specs */
4605 };
4606
4607 static asn_TYPE_member_t asn_MBR_value_16[] = {
4608         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs__value, choice.RANfunction_Item),
4609                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4610                 0,
4611                 &asn_DEF_RANfunction_Item,
4612                 0,
4613                 { 0, 0, 0 },
4614                 0, 0, /* No default value */
4615                 "RANfunction-Item"
4616                 },
4617 };
4618 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_16[] = {
4619     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunction-Item */
4620 };
4621 static asn_CHOICE_specifics_t asn_SPC_value_specs_16 = {
4622         sizeof(struct RANfunction_ItemIEs__value),
4623         offsetof(struct RANfunction_ItemIEs__value, _asn_ctx),
4624         offsetof(struct RANfunction_ItemIEs__value, present),
4625         sizeof(((struct RANfunction_ItemIEs__value *)0)->present),
4626         asn_MAP_value_tag2el_16,
4627         1,      /* Count of tags in the map */
4628         0, 0,
4629         -1      /* Extensions start */
4630 };
4631 static /* Use -fall-defs-global to expose */
4632 asn_TYPE_descriptor_t asn_DEF_value_16 = {
4633         "value",
4634         "value",
4635         &asn_OP_OPEN_TYPE,
4636         0,      /* No effective tags (pointer) */
4637         0,      /* No effective tags (count) */
4638         0,      /* No tags (pointer) */
4639         0,      /* No tags (count) */
4640         { 0, 0, OPEN_TYPE_constraint },
4641         asn_MBR_value_16,
4642         1,      /* Elements count */
4643         &asn_SPC_value_specs_16 /* Additional specs */
4644 };
4645
4646 asn_TYPE_member_t asn_MBR_RANfunction_ItemIEs_13[] = {
4647         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, id),
4648                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4649                 0,
4650                 &asn_DEF_ProtocolIE_ID,
4651                 0,
4652                 { &asn_OER_memb_id_constr_14, &asn_PER_memb_id_constr_14,  memb_id_constraint_13 },
4653                 0, 0, /* No default value */
4654                 "id"
4655                 },
4656         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, criticality),
4657                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4658                 0,
4659                 &asn_DEF_Criticality,
4660                 select_RANfunction_ItemIEs_criticality_type,
4661                 { &asn_OER_memb_criticality_constr_15, &asn_PER_memb_criticality_constr_15,  memb_criticality_constraint_13 },
4662                 0, 0, /* No default value */
4663                 "criticality"
4664                 },
4665         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, value),
4666                 -1 /* Ambiguous tag (ANY?) */,
4667                 0,
4668                 &asn_DEF_value_16,
4669                 select_RANfunction_ItemIEs_value_type,
4670                 { &asn_OER_memb_value_constr_16, &asn_PER_memb_value_constr_16,  memb_value_constraint_13 },
4671                 0, 0, /* No default value */
4672                 "value"
4673                 },
4674 };
4675 static const ber_tlv_tag_t asn_DEF_RANfunction_ItemIEs_tags_13[] = {
4676         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4677 };
4678 static const asn_TYPE_tag2member_t asn_MAP_RANfunction_ItemIEs_tag2el_13[] = {
4679     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
4680     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
4681 };
4682 asn_SEQUENCE_specifics_t asn_SPC_RANfunction_ItemIEs_specs_13 = {
4683         sizeof(struct RANfunction_ItemIEs),
4684         offsetof(struct RANfunction_ItemIEs, _asn_ctx),
4685         asn_MAP_RANfunction_ItemIEs_tag2el_13,
4686         2,      /* Count of tags in the map */
4687         0, 0, 0,        /* Optional elements (not needed) */
4688         -1,     /* First extension addition */
4689 };
4690 asn_TYPE_descriptor_t asn_DEF_RANfunction_ItemIEs = {
4691         "RANfunction-ItemIEs",
4692         "RANfunction-ItemIEs",
4693         &asn_OP_SEQUENCE,
4694         asn_DEF_RANfunction_ItemIEs_tags_13,
4695         sizeof(asn_DEF_RANfunction_ItemIEs_tags_13)
4696                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_13[0]), /* 1 */
4697         asn_DEF_RANfunction_ItemIEs_tags_13,    /* Same as above */
4698         sizeof(asn_DEF_RANfunction_ItemIEs_tags_13)
4699                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_13[0]), /* 1 */
4700         { 0, 0, SEQUENCE_constraint },
4701         asn_MBR_RANfunction_ItemIEs_13,
4702         3,      /* Elements count */
4703         &asn_SPC_RANfunction_ItemIEs_specs_13   /* Additional specs */
4704 };
4705
4706 static asn_TYPE_member_t asn_MBR_value_20[] = {
4707         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs__value, choice.RANfunctionID_Item),
4708                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4709                 0,
4710                 &asn_DEF_RANfunctionID_Item,
4711                 0,
4712                 { 0, 0, 0 },
4713                 0, 0, /* No default value */
4714                 "RANfunctionID-Item"
4715                 },
4716 };
4717 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_20[] = {
4718     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionID-Item */
4719 };
4720 static asn_CHOICE_specifics_t asn_SPC_value_specs_20 = {
4721         sizeof(struct RANfunctionID_ItemIEs__value),
4722         offsetof(struct RANfunctionID_ItemIEs__value, _asn_ctx),
4723         offsetof(struct RANfunctionID_ItemIEs__value, present),
4724         sizeof(((struct RANfunctionID_ItemIEs__value *)0)->present),
4725         asn_MAP_value_tag2el_20,
4726         1,      /* Count of tags in the map */
4727         0, 0,
4728         -1      /* Extensions start */
4729 };
4730 static /* Use -fall-defs-global to expose */
4731 asn_TYPE_descriptor_t asn_DEF_value_20 = {
4732         "value",
4733         "value",
4734         &asn_OP_OPEN_TYPE,
4735         0,      /* No effective tags (pointer) */
4736         0,      /* No effective tags (count) */
4737         0,      /* No tags (pointer) */
4738         0,      /* No tags (count) */
4739         { 0, 0, OPEN_TYPE_constraint },
4740         asn_MBR_value_20,
4741         1,      /* Elements count */
4742         &asn_SPC_value_specs_20 /* Additional specs */
4743 };
4744
4745 asn_TYPE_member_t asn_MBR_RANfunctionID_ItemIEs_17[] = {
4746         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, id),
4747                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4748                 0,
4749                 &asn_DEF_ProtocolIE_ID,
4750                 0,
4751                 { &asn_OER_memb_id_constr_18, &asn_PER_memb_id_constr_18,  memb_id_constraint_17 },
4752                 0, 0, /* No default value */
4753                 "id"
4754                 },
4755         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, criticality),
4756                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4757                 0,
4758                 &asn_DEF_Criticality,
4759                 select_RANfunctionID_ItemIEs_criticality_type,
4760                 { &asn_OER_memb_criticality_constr_19, &asn_PER_memb_criticality_constr_19,  memb_criticality_constraint_17 },
4761                 0, 0, /* No default value */
4762                 "criticality"
4763                 },
4764         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, value),
4765                 -1 /* Ambiguous tag (ANY?) */,
4766                 0,
4767                 &asn_DEF_value_20,
4768                 select_RANfunctionID_ItemIEs_value_type,
4769                 { &asn_OER_memb_value_constr_20, &asn_PER_memb_value_constr_20,  memb_value_constraint_17 },
4770                 0, 0, /* No default value */
4771                 "value"
4772                 },
4773 };
4774 static const ber_tlv_tag_t asn_DEF_RANfunctionID_ItemIEs_tags_17[] = {
4775         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4776 };
4777 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionID_ItemIEs_tag2el_17[] = {
4778     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
4779     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
4780 };
4781 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionID_ItemIEs_specs_17 = {
4782         sizeof(struct RANfunctionID_ItemIEs),
4783         offsetof(struct RANfunctionID_ItemIEs, _asn_ctx),
4784         asn_MAP_RANfunctionID_ItemIEs_tag2el_17,
4785         2,      /* Count of tags in the map */
4786         0, 0, 0,        /* Optional elements (not needed) */
4787         -1,     /* First extension addition */
4788 };
4789 asn_TYPE_descriptor_t asn_DEF_RANfunctionID_ItemIEs = {
4790         "RANfunctionID-ItemIEs",
4791         "RANfunctionID-ItemIEs",
4792         &asn_OP_SEQUENCE,
4793         asn_DEF_RANfunctionID_ItemIEs_tags_17,
4794         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17)
4795                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
4796         asn_DEF_RANfunctionID_ItemIEs_tags_17,  /* Same as above */
4797         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17)
4798                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
4799         { 0, 0, SEQUENCE_constraint },
4800         asn_MBR_RANfunctionID_ItemIEs_17,
4801         3,      /* Elements count */
4802         &asn_SPC_RANfunctionID_ItemIEs_specs_17 /* Additional specs */
4803 };
4804
4805 static asn_TYPE_member_t asn_MBR_value_24[] = {
4806         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs__value, choice.RANfunctionIDcause_Item),
4807                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4808                 0,
4809                 &asn_DEF_RANfunctionIDcause_Item,
4810                 0,
4811                 { 0, 0, 0 },
4812                 0, 0, /* No default value */
4813                 "RANfunctionIDcause-Item"
4814                 },
4815 };
4816 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_24[] = {
4817     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionIDcause-Item */
4818 };
4819 static asn_CHOICE_specifics_t asn_SPC_value_specs_24 = {
4820         sizeof(struct RANfunctionIDcause_ItemIEs__value),
4821         offsetof(struct RANfunctionIDcause_ItemIEs__value, _asn_ctx),
4822         offsetof(struct RANfunctionIDcause_ItemIEs__value, present),
4823         sizeof(((struct RANfunctionIDcause_ItemIEs__value *)0)->present),
4824         asn_MAP_value_tag2el_24,
4825         1,      /* Count of tags in the map */
4826         0, 0,
4827         -1      /* Extensions start */
4828 };
4829 static /* Use -fall-defs-global to expose */
4830 asn_TYPE_descriptor_t asn_DEF_value_24 = {
4831         "value",
4832         "value",
4833         &asn_OP_OPEN_TYPE,
4834         0,      /* No effective tags (pointer) */
4835         0,      /* No effective tags (count) */
4836         0,      /* No tags (pointer) */
4837         0,      /* No tags (count) */
4838         { 0, 0, OPEN_TYPE_constraint },
4839         asn_MBR_value_24,
4840         1,      /* Elements count */
4841         &asn_SPC_value_specs_24 /* Additional specs */
4842 };
4843
4844 asn_TYPE_member_t asn_MBR_RANfunctionIDcause_ItemIEs_21[] = {
4845         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, id),
4846                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4847                 0,
4848                 &asn_DEF_ProtocolIE_ID,
4849                 0,
4850                 { &asn_OER_memb_id_constr_22, &asn_PER_memb_id_constr_22,  memb_id_constraint_21 },
4851                 0, 0, /* No default value */
4852                 "id"
4853                 },
4854         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, criticality),
4855                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4856                 0,
4857                 &asn_DEF_Criticality,
4858                 select_RANfunctionIDcause_ItemIEs_criticality_type,
4859                 { &asn_OER_memb_criticality_constr_23, &asn_PER_memb_criticality_constr_23,  memb_criticality_constraint_21 },
4860                 0, 0, /* No default value */
4861                 "criticality"
4862                 },
4863         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, value),
4864                 -1 /* Ambiguous tag (ANY?) */,
4865                 0,
4866                 &asn_DEF_value_24,
4867                 select_RANfunctionIDcause_ItemIEs_value_type,
4868                 { &asn_OER_memb_value_constr_24, &asn_PER_memb_value_constr_24,  memb_value_constraint_21 },
4869                 0, 0, /* No default value */
4870                 "value"
4871                 },
4872 };
4873 static const ber_tlv_tag_t asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[] = {
4874         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4875 };
4876 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_21[] = {
4877     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
4878     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
4879 };
4880 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionIDcause_ItemIEs_specs_21 = {
4881         sizeof(struct RANfunctionIDcause_ItemIEs),
4882         offsetof(struct RANfunctionIDcause_ItemIEs, _asn_ctx),
4883         asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_21,
4884         2,      /* Count of tags in the map */
4885         0, 0, 0,        /* Optional elements (not needed) */
4886         -1,     /* First extension addition */
4887 };
4888 asn_TYPE_descriptor_t asn_DEF_RANfunctionIDcause_ItemIEs = {
4889         "RANfunctionIDcause-ItemIEs",
4890         "RANfunctionIDcause-ItemIEs",
4891         &asn_OP_SEQUENCE,
4892         asn_DEF_RANfunctionIDcause_ItemIEs_tags_21,
4893         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21)
4894                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
4895         asn_DEF_RANfunctionIDcause_ItemIEs_tags_21,     /* Same as above */
4896         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21)
4897                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
4898         { 0, 0, SEQUENCE_constraint },
4899         asn_MBR_RANfunctionIDcause_ItemIEs_21,
4900         3,      /* Elements count */
4901         &asn_SPC_RANfunctionIDcause_ItemIEs_specs_21    /* Additional specs */
4902 };
4903
4904 static asn_TYPE_member_t asn_MBR_value_28[] = {
4905         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICrequestID),
4906                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4907                 0,
4908                 &asn_DEF_RICrequestID,
4909                 0,
4910                 { 0, 0, 0 },
4911                 0, 0, /* No default value */
4912                 "RICrequestID"
4913                 },
4914         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RANfunctionID),
4915                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4916                 0,
4917                 &asn_DEF_RANfunctionID,
4918                 0,
4919                 { 0, 0, 0 },
4920                 0, 0, /* No default value */
4921                 "RANfunctionID"
4922                 },
4923         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICsubscriptionDetails),
4924                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4925                 0,
4926                 &asn_DEF_RICsubscriptionDetails,
4927                 0,
4928                 { 0, 0, 0 },
4929                 0, 0, /* No default value */
4930                 "RICsubscriptionDetails"
4931                 },
4932 };
4933 static const unsigned asn_MAP_value_to_canonical_28[] = { 1, 0, 2 };
4934 static const unsigned asn_MAP_value_from_canonical_28[] = { 1, 0, 2 };
4935 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_28[] = {
4936     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4937     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
4938     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* RICsubscriptionDetails */
4939 };
4940 static asn_CHOICE_specifics_t asn_SPC_value_specs_28 = {
4941         sizeof(struct RICsubscriptionRequest_IEs__value),
4942         offsetof(struct RICsubscriptionRequest_IEs__value, _asn_ctx),
4943         offsetof(struct RICsubscriptionRequest_IEs__value, present),
4944         sizeof(((struct RICsubscriptionRequest_IEs__value *)0)->present),
4945         asn_MAP_value_tag2el_28,
4946         3,      /* Count of tags in the map */
4947         asn_MAP_value_to_canonical_28,
4948         asn_MAP_value_from_canonical_28,
4949         -1      /* Extensions start */
4950 };
4951 static /* Use -fall-defs-global to expose */
4952 asn_TYPE_descriptor_t asn_DEF_value_28 = {
4953         "value",
4954         "value",
4955         &asn_OP_OPEN_TYPE,
4956         0,      /* No effective tags (pointer) */
4957         0,      /* No effective tags (count) */
4958         0,      /* No tags (pointer) */
4959         0,      /* No tags (count) */
4960         { 0, 0, OPEN_TYPE_constraint },
4961         asn_MBR_value_28,
4962         3,      /* Elements count */
4963         &asn_SPC_value_specs_28 /* Additional specs */
4964 };
4965
4966 asn_TYPE_member_t asn_MBR_RICsubscriptionRequest_IEs_25[] = {
4967         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, id),
4968                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4969                 0,
4970                 &asn_DEF_ProtocolIE_ID,
4971                 0,
4972                 { &asn_OER_memb_id_constr_26, &asn_PER_memb_id_constr_26,  memb_id_constraint_25 },
4973                 0, 0, /* No default value */
4974                 "id"
4975                 },
4976         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, criticality),
4977                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
4978                 0,
4979                 &asn_DEF_Criticality,
4980                 select_RICsubscriptionRequest_IEs_criticality_type,
4981                 { &asn_OER_memb_criticality_constr_27, &asn_PER_memb_criticality_constr_27,  memb_criticality_constraint_25 },
4982                 0, 0, /* No default value */
4983                 "criticality"
4984                 },
4985         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, value),
4986                 -1 /* Ambiguous tag (ANY?) */,
4987                 0,
4988                 &asn_DEF_value_28,
4989                 select_RICsubscriptionRequest_IEs_value_type,
4990                 { &asn_OER_memb_value_constr_28, &asn_PER_memb_value_constr_28,  memb_value_constraint_25 },
4991                 0, 0, /* No default value */
4992                 "value"
4993                 },
4994 };
4995 static const ber_tlv_tag_t asn_DEF_RICsubscriptionRequest_IEs_tags_25[] = {
4996         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4997 };
4998 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionRequest_IEs_tag2el_25[] = {
4999     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5000     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5001 };
5002 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionRequest_IEs_specs_25 = {
5003         sizeof(struct RICsubscriptionRequest_IEs),
5004         offsetof(struct RICsubscriptionRequest_IEs, _asn_ctx),
5005         asn_MAP_RICsubscriptionRequest_IEs_tag2el_25,
5006         2,      /* Count of tags in the map */
5007         0, 0, 0,        /* Optional elements (not needed) */
5008         -1,     /* First extension addition */
5009 };
5010 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionRequest_IEs = {
5011         "RICsubscriptionRequest-IEs",
5012         "RICsubscriptionRequest-IEs",
5013         &asn_OP_SEQUENCE,
5014         asn_DEF_RICsubscriptionRequest_IEs_tags_25,
5015         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25)
5016                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
5017         asn_DEF_RICsubscriptionRequest_IEs_tags_25,     /* Same as above */
5018         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25)
5019                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
5020         { 0, 0, SEQUENCE_constraint },
5021         asn_MBR_RICsubscriptionRequest_IEs_25,
5022         3,      /* Elements count */
5023         &asn_SPC_RICsubscriptionRequest_IEs_specs_25    /* Additional specs */
5024 };
5025
5026 static asn_TYPE_member_t asn_MBR_value_32[] = {
5027         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICrequestID),
5028                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5029                 0,
5030                 &asn_DEF_RICrequestID,
5031                 0,
5032                 { 0, 0, 0 },
5033                 0, 0, /* No default value */
5034                 "RICrequestID"
5035                 },
5036         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RANfunctionID),
5037                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5038                 0,
5039                 &asn_DEF_RANfunctionID,
5040                 0,
5041                 { 0, 0, 0 },
5042                 0, 0, /* No default value */
5043                 "RANfunctionID"
5044                 },
5045         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_Admitted_List),
5046                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5047                 0,
5048                 &asn_DEF_RICaction_Admitted_List,
5049                 0,
5050                 { 0, 0, 0 },
5051                 0, 0, /* No default value */
5052                 "RICaction-Admitted-List"
5053                 },
5054         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_NotAdmitted_List),
5055                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5056                 0,
5057                 &asn_DEF_RICaction_NotAdmitted_List,
5058                 0,
5059                 { 0, 0, 0 },
5060                 0, 0, /* No default value */
5061                 "RICaction-NotAdmitted-List"
5062                 },
5063 };
5064 static const unsigned asn_MAP_value_to_canonical_32[] = { 1, 0, 2, 3 };
5065 static const unsigned asn_MAP_value_from_canonical_32[] = { 1, 0, 2, 3 };
5066 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_32[] = {
5067     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5068     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
5069     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-Admitted-List */
5070     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* RICaction-NotAdmitted-List */
5071 };
5072 static asn_CHOICE_specifics_t asn_SPC_value_specs_32 = {
5073         sizeof(struct RICsubscriptionResponse_IEs__value),
5074         offsetof(struct RICsubscriptionResponse_IEs__value, _asn_ctx),
5075         offsetof(struct RICsubscriptionResponse_IEs__value, present),
5076         sizeof(((struct RICsubscriptionResponse_IEs__value *)0)->present),
5077         asn_MAP_value_tag2el_32,
5078         4,      /* Count of tags in the map */
5079         asn_MAP_value_to_canonical_32,
5080         asn_MAP_value_from_canonical_32,
5081         -1      /* Extensions start */
5082 };
5083 static /* Use -fall-defs-global to expose */
5084 asn_TYPE_descriptor_t asn_DEF_value_32 = {
5085         "value",
5086         "value",
5087         &asn_OP_OPEN_TYPE,
5088         0,      /* No effective tags (pointer) */
5089         0,      /* No effective tags (count) */
5090         0,      /* No tags (pointer) */
5091         0,      /* No tags (count) */
5092         { 0, 0, OPEN_TYPE_constraint },
5093         asn_MBR_value_32,
5094         4,      /* Elements count */
5095         &asn_SPC_value_specs_32 /* Additional specs */
5096 };
5097
5098 asn_TYPE_member_t asn_MBR_RICsubscriptionResponse_IEs_29[] = {
5099         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, id),
5100                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5101                 0,
5102                 &asn_DEF_ProtocolIE_ID,
5103                 0,
5104                 { &asn_OER_memb_id_constr_30, &asn_PER_memb_id_constr_30,  memb_id_constraint_29 },
5105                 0, 0, /* No default value */
5106                 "id"
5107                 },
5108         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, criticality),
5109                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5110                 0,
5111                 &asn_DEF_Criticality,
5112                 select_RICsubscriptionResponse_IEs_criticality_type,
5113                 { &asn_OER_memb_criticality_constr_31, &asn_PER_memb_criticality_constr_31,  memb_criticality_constraint_29 },
5114                 0, 0, /* No default value */
5115                 "criticality"
5116                 },
5117         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, value),
5118                 -1 /* Ambiguous tag (ANY?) */,
5119                 0,
5120                 &asn_DEF_value_32,
5121                 select_RICsubscriptionResponse_IEs_value_type,
5122                 { &asn_OER_memb_value_constr_32, &asn_PER_memb_value_constr_32,  memb_value_constraint_29 },
5123                 0, 0, /* No default value */
5124                 "value"
5125                 },
5126 };
5127 static const ber_tlv_tag_t asn_DEF_RICsubscriptionResponse_IEs_tags_29[] = {
5128         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5129 };
5130 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionResponse_IEs_tag2el_29[] = {
5131     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5132     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5133 };
5134 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionResponse_IEs_specs_29 = {
5135         sizeof(struct RICsubscriptionResponse_IEs),
5136         offsetof(struct RICsubscriptionResponse_IEs, _asn_ctx),
5137         asn_MAP_RICsubscriptionResponse_IEs_tag2el_29,
5138         2,      /* Count of tags in the map */
5139         0, 0, 0,        /* Optional elements (not needed) */
5140         -1,     /* First extension addition */
5141 };
5142 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionResponse_IEs = {
5143         "RICsubscriptionResponse-IEs",
5144         "RICsubscriptionResponse-IEs",
5145         &asn_OP_SEQUENCE,
5146         asn_DEF_RICsubscriptionResponse_IEs_tags_29,
5147         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29)
5148                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
5149         asn_DEF_RICsubscriptionResponse_IEs_tags_29,    /* Same as above */
5150         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29)
5151                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
5152         { 0, 0, SEQUENCE_constraint },
5153         asn_MBR_RICsubscriptionResponse_IEs_29,
5154         3,      /* Elements count */
5155         &asn_SPC_RICsubscriptionResponse_IEs_specs_29   /* Additional specs */
5156 };
5157
5158 static asn_TYPE_member_t asn_MBR_value_36[] = {
5159         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICrequestID),
5160                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5161                 0,
5162                 &asn_DEF_RICrequestID,
5163                 0,
5164                 { 0, 0, 0 },
5165                 0, 0, /* No default value */
5166                 "RICrequestID"
5167                 },
5168         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RANfunctionID),
5169                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5170                 0,
5171                 &asn_DEF_RANfunctionID,
5172                 0,
5173                 { 0, 0, 0 },
5174                 0, 0, /* No default value */
5175                 "RANfunctionID"
5176                 },
5177         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICaction_NotAdmitted_List),
5178                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5179                 0,
5180                 &asn_DEF_RICaction_NotAdmitted_List,
5181                 0,
5182                 { 0, 0, 0 },
5183                 0, 0, /* No default value */
5184                 "RICaction-NotAdmitted-List"
5185                 },
5186         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.CriticalityDiagnostics),
5187                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5188                 0,
5189                 &asn_DEF_CriticalityDiagnostics,
5190                 0,
5191                 { 0, 0, 0 },
5192                 0, 0, /* No default value */
5193                 "CriticalityDiagnostics"
5194                 },
5195 };
5196 static const unsigned asn_MAP_value_to_canonical_36[] = { 1, 0, 2, 3 };
5197 static const unsigned asn_MAP_value_from_canonical_36[] = { 1, 0, 2, 3 };
5198 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_36[] = {
5199     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5200     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
5201     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-NotAdmitted-List */
5202     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* CriticalityDiagnostics */
5203 };
5204 static asn_CHOICE_specifics_t asn_SPC_value_specs_36 = {
5205         sizeof(struct RICsubscriptionFailure_IEs__value),
5206         offsetof(struct RICsubscriptionFailure_IEs__value, _asn_ctx),
5207         offsetof(struct RICsubscriptionFailure_IEs__value, present),
5208         sizeof(((struct RICsubscriptionFailure_IEs__value *)0)->present),
5209         asn_MAP_value_tag2el_36,
5210         4,      /* Count of tags in the map */
5211         asn_MAP_value_to_canonical_36,
5212         asn_MAP_value_from_canonical_36,
5213         -1      /* Extensions start */
5214 };
5215 static /* Use -fall-defs-global to expose */
5216 asn_TYPE_descriptor_t asn_DEF_value_36 = {
5217         "value",
5218         "value",
5219         &asn_OP_OPEN_TYPE,
5220         0,      /* No effective tags (pointer) */
5221         0,      /* No effective tags (count) */
5222         0,      /* No tags (pointer) */
5223         0,      /* No tags (count) */
5224         { 0, 0, OPEN_TYPE_constraint },
5225         asn_MBR_value_36,
5226         4,      /* Elements count */
5227         &asn_SPC_value_specs_36 /* Additional specs */
5228 };
5229
5230 asn_TYPE_member_t asn_MBR_RICsubscriptionFailure_IEs_33[] = {
5231         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, id),
5232                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5233                 0,
5234                 &asn_DEF_ProtocolIE_ID,
5235                 0,
5236                 { &asn_OER_memb_id_constr_34, &asn_PER_memb_id_constr_34,  memb_id_constraint_33 },
5237                 0, 0, /* No default value */
5238                 "id"
5239                 },
5240         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, criticality),
5241                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5242                 0,
5243                 &asn_DEF_Criticality,
5244                 select_RICsubscriptionFailure_IEs_criticality_type,
5245                 { &asn_OER_memb_criticality_constr_35, &asn_PER_memb_criticality_constr_35,  memb_criticality_constraint_33 },
5246                 0, 0, /* No default value */
5247                 "criticality"
5248                 },
5249         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, value),
5250                 -1 /* Ambiguous tag (ANY?) */,
5251                 0,
5252                 &asn_DEF_value_36,
5253                 select_RICsubscriptionFailure_IEs_value_type,
5254                 { &asn_OER_memb_value_constr_36, &asn_PER_memb_value_constr_36,  memb_value_constraint_33 },
5255                 0, 0, /* No default value */
5256                 "value"
5257                 },
5258 };
5259 static const ber_tlv_tag_t asn_DEF_RICsubscriptionFailure_IEs_tags_33[] = {
5260         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5261 };
5262 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionFailure_IEs_tag2el_33[] = {
5263     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5264     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5265 };
5266 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionFailure_IEs_specs_33 = {
5267         sizeof(struct RICsubscriptionFailure_IEs),
5268         offsetof(struct RICsubscriptionFailure_IEs, _asn_ctx),
5269         asn_MAP_RICsubscriptionFailure_IEs_tag2el_33,
5270         2,      /* Count of tags in the map */
5271         0, 0, 0,        /* Optional elements (not needed) */
5272         -1,     /* First extension addition */
5273 };
5274 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionFailure_IEs = {
5275         "RICsubscriptionFailure-IEs",
5276         "RICsubscriptionFailure-IEs",
5277         &asn_OP_SEQUENCE,
5278         asn_DEF_RICsubscriptionFailure_IEs_tags_33,
5279         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33)
5280                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
5281         asn_DEF_RICsubscriptionFailure_IEs_tags_33,     /* Same as above */
5282         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33)
5283                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
5284         { 0, 0, SEQUENCE_constraint },
5285         asn_MBR_RICsubscriptionFailure_IEs_33,
5286         3,      /* Elements count */
5287         &asn_SPC_RICsubscriptionFailure_IEs_specs_33    /* Additional specs */
5288 };
5289
5290 static asn_TYPE_member_t asn_MBR_value_40[] = {
5291         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RICrequestID),
5292                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5293                 0,
5294                 &asn_DEF_RICrequestID,
5295                 0,
5296                 { 0, 0, 0 },
5297                 0, 0, /* No default value */
5298                 "RICrequestID"
5299                 },
5300         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RANfunctionID),
5301                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5302                 0,
5303                 &asn_DEF_RANfunctionID,
5304                 0,
5305                 { 0, 0, 0 },
5306                 0, 0, /* No default value */
5307                 "RANfunctionID"
5308                 },
5309 };
5310 static const unsigned asn_MAP_value_to_canonical_40[] = { 1, 0 };
5311 static const unsigned asn_MAP_value_from_canonical_40[] = { 1, 0 };
5312 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_40[] = {
5313     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5314     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5315 };
5316 static asn_CHOICE_specifics_t asn_SPC_value_specs_40 = {
5317         sizeof(struct RICsubscriptionDeleteRequest_IEs__value),
5318         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, _asn_ctx),
5319         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, present),
5320         sizeof(((struct RICsubscriptionDeleteRequest_IEs__value *)0)->present),
5321         asn_MAP_value_tag2el_40,
5322         2,      /* Count of tags in the map */
5323         asn_MAP_value_to_canonical_40,
5324         asn_MAP_value_from_canonical_40,
5325         -1      /* Extensions start */
5326 };
5327 static /* Use -fall-defs-global to expose */
5328 asn_TYPE_descriptor_t asn_DEF_value_40 = {
5329         "value",
5330         "value",
5331         &asn_OP_OPEN_TYPE,
5332         0,      /* No effective tags (pointer) */
5333         0,      /* No effective tags (count) */
5334         0,      /* No tags (pointer) */
5335         0,      /* No tags (count) */
5336         { 0, 0, OPEN_TYPE_constraint },
5337         asn_MBR_value_40,
5338         2,      /* Elements count */
5339         &asn_SPC_value_specs_40 /* Additional specs */
5340 };
5341
5342 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteRequest_IEs_37[] = {
5343         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, id),
5344                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5345                 0,
5346                 &asn_DEF_ProtocolIE_ID,
5347                 0,
5348                 { &asn_OER_memb_id_constr_38, &asn_PER_memb_id_constr_38,  memb_id_constraint_37 },
5349                 0, 0, /* No default value */
5350                 "id"
5351                 },
5352         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, criticality),
5353                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5354                 0,
5355                 &asn_DEF_Criticality,
5356                 select_RICsubscriptionDeleteRequest_IEs_criticality_type,
5357                 { &asn_OER_memb_criticality_constr_39, &asn_PER_memb_criticality_constr_39,  memb_criticality_constraint_37 },
5358                 0, 0, /* No default value */
5359                 "criticality"
5360                 },
5361         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, value),
5362                 -1 /* Ambiguous tag (ANY?) */,
5363                 0,
5364                 &asn_DEF_value_40,
5365                 select_RICsubscriptionDeleteRequest_IEs_value_type,
5366                 { &asn_OER_memb_value_constr_40, &asn_PER_memb_value_constr_40,  memb_value_constraint_37 },
5367                 0, 0, /* No default value */
5368                 "value"
5369                 },
5370 };
5371 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[] = {
5372         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5373 };
5374 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_37[] = {
5375     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5376     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5377 };
5378 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_37 = {
5379         sizeof(struct RICsubscriptionDeleteRequest_IEs),
5380         offsetof(struct RICsubscriptionDeleteRequest_IEs, _asn_ctx),
5381         asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_37,
5382         2,      /* Count of tags in the map */
5383         0, 0, 0,        /* Optional elements (not needed) */
5384         -1,     /* First extension addition */
5385 };
5386 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteRequest_IEs = {
5387         "RICsubscriptionDeleteRequest-IEs",
5388         "RICsubscriptionDeleteRequest-IEs",
5389         &asn_OP_SEQUENCE,
5390         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37,
5391         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37)
5392                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
5393         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37,       /* Same as above */
5394         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37)
5395                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
5396         { 0, 0, SEQUENCE_constraint },
5397         asn_MBR_RICsubscriptionDeleteRequest_IEs_37,
5398         3,      /* Elements count */
5399         &asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_37      /* Additional specs */
5400 };
5401
5402 static asn_TYPE_member_t asn_MBR_value_44[] = {
5403         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RICrequestID),
5404                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5405                 0,
5406                 &asn_DEF_RICrequestID,
5407                 0,
5408                 { 0, 0, 0 },
5409                 0, 0, /* No default value */
5410                 "RICrequestID"
5411                 },
5412         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RANfunctionID),
5413                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5414                 0,
5415                 &asn_DEF_RANfunctionID,
5416                 0,
5417                 { 0, 0, 0 },
5418                 0, 0, /* No default value */
5419                 "RANfunctionID"
5420                 },
5421 };
5422 static const unsigned asn_MAP_value_to_canonical_44[] = { 1, 0 };
5423 static const unsigned asn_MAP_value_from_canonical_44[] = { 1, 0 };
5424 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_44[] = {
5425     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5426     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5427 };
5428 static asn_CHOICE_specifics_t asn_SPC_value_specs_44 = {
5429         sizeof(struct RICsubscriptionDeleteResponse_IEs__value),
5430         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, _asn_ctx),
5431         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, present),
5432         sizeof(((struct RICsubscriptionDeleteResponse_IEs__value *)0)->present),
5433         asn_MAP_value_tag2el_44,
5434         2,      /* Count of tags in the map */
5435         asn_MAP_value_to_canonical_44,
5436         asn_MAP_value_from_canonical_44,
5437         -1      /* Extensions start */
5438 };
5439 static /* Use -fall-defs-global to expose */
5440 asn_TYPE_descriptor_t asn_DEF_value_44 = {
5441         "value",
5442         "value",
5443         &asn_OP_OPEN_TYPE,
5444         0,      /* No effective tags (pointer) */
5445         0,      /* No effective tags (count) */
5446         0,      /* No tags (pointer) */
5447         0,      /* No tags (count) */
5448         { 0, 0, OPEN_TYPE_constraint },
5449         asn_MBR_value_44,
5450         2,      /* Elements count */
5451         &asn_SPC_value_specs_44 /* Additional specs */
5452 };
5453
5454 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteResponse_IEs_41[] = {
5455         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, id),
5456                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5457                 0,
5458                 &asn_DEF_ProtocolIE_ID,
5459                 0,
5460                 { &asn_OER_memb_id_constr_42, &asn_PER_memb_id_constr_42,  memb_id_constraint_41 },
5461                 0, 0, /* No default value */
5462                 "id"
5463                 },
5464         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, criticality),
5465                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5466                 0,
5467                 &asn_DEF_Criticality,
5468                 select_RICsubscriptionDeleteResponse_IEs_criticality_type,
5469                 { &asn_OER_memb_criticality_constr_43, &asn_PER_memb_criticality_constr_43,  memb_criticality_constraint_41 },
5470                 0, 0, /* No default value */
5471                 "criticality"
5472                 },
5473         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, value),
5474                 -1 /* Ambiguous tag (ANY?) */,
5475                 0,
5476                 &asn_DEF_value_44,
5477                 select_RICsubscriptionDeleteResponse_IEs_value_type,
5478                 { &asn_OER_memb_value_constr_44, &asn_PER_memb_value_constr_44,  memb_value_constraint_41 },
5479                 0, 0, /* No default value */
5480                 "value"
5481                 },
5482 };
5483 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[] = {
5484         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5485 };
5486 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_41[] = {
5487     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5488     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5489 };
5490 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_41 = {
5491         sizeof(struct RICsubscriptionDeleteResponse_IEs),
5492         offsetof(struct RICsubscriptionDeleteResponse_IEs, _asn_ctx),
5493         asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_41,
5494         2,      /* Count of tags in the map */
5495         0, 0, 0,        /* Optional elements (not needed) */
5496         -1,     /* First extension addition */
5497 };
5498 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteResponse_IEs = {
5499         "RICsubscriptionDeleteResponse-IEs",
5500         "RICsubscriptionDeleteResponse-IEs",
5501         &asn_OP_SEQUENCE,
5502         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41,
5503         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41)
5504                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
5505         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41,      /* Same as above */
5506         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41)
5507                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
5508         { 0, 0, SEQUENCE_constraint },
5509         asn_MBR_RICsubscriptionDeleteResponse_IEs_41,
5510         3,      /* Elements count */
5511         &asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_41     /* Additional specs */
5512 };
5513
5514 static asn_TYPE_member_t asn_MBR_value_48[] = {
5515         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RICrequestID),
5516                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5517                 0,
5518                 &asn_DEF_RICrequestID,
5519                 0,
5520                 { 0, 0, 0 },
5521                 0, 0, /* No default value */
5522                 "RICrequestID"
5523                 },
5524         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RANfunctionID),
5525                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5526                 0,
5527                 &asn_DEF_RANfunctionID,
5528                 0,
5529                 { 0, 0, 0 },
5530                 0, 0, /* No default value */
5531                 "RANfunctionID"
5532                 },
5533         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.Cause),
5534                 -1 /* Ambiguous tag (CHOICE?) */,
5535                 0,
5536                 &asn_DEF_Cause,
5537                 0,
5538                 { 0, 0, 0 },
5539                 0, 0, /* No default value */
5540                 "Cause"
5541                 },
5542         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.CriticalityDiagnostics),
5543                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5544                 0,
5545                 &asn_DEF_CriticalityDiagnostics,
5546                 0,
5547                 { 0, 0, 0 },
5548                 0, 0, /* No default value */
5549                 "CriticalityDiagnostics"
5550                 },
5551 };
5552 static const unsigned asn_MAP_value_to_canonical_48[] = { 1, 0, 3, 2 };
5553 static const unsigned asn_MAP_value_from_canonical_48[] = { 1, 0, 3, 2 };
5554 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_48[] = {
5555     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5556     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
5557     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
5558     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
5559     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
5560     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
5561     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
5562     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
5563 };
5564 static asn_CHOICE_specifics_t asn_SPC_value_specs_48 = {
5565         sizeof(struct RICsubscriptionDeleteFailure_IEs__value),
5566         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, _asn_ctx),
5567         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, present),
5568         sizeof(((struct RICsubscriptionDeleteFailure_IEs__value *)0)->present),
5569         asn_MAP_value_tag2el_48,
5570         8,      /* Count of tags in the map */
5571         asn_MAP_value_to_canonical_48,
5572         asn_MAP_value_from_canonical_48,
5573         -1      /* Extensions start */
5574 };
5575 static /* Use -fall-defs-global to expose */
5576 asn_TYPE_descriptor_t asn_DEF_value_48 = {
5577         "value",
5578         "value",
5579         &asn_OP_OPEN_TYPE,
5580         0,      /* No effective tags (pointer) */
5581         0,      /* No effective tags (count) */
5582         0,      /* No tags (pointer) */
5583         0,      /* No tags (count) */
5584         { 0, 0, OPEN_TYPE_constraint },
5585         asn_MBR_value_48,
5586         4,      /* Elements count */
5587         &asn_SPC_value_specs_48 /* Additional specs */
5588 };
5589
5590 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteFailure_IEs_45[] = {
5591         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, id),
5592                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5593                 0,
5594                 &asn_DEF_ProtocolIE_ID,
5595                 0,
5596                 { &asn_OER_memb_id_constr_46, &asn_PER_memb_id_constr_46,  memb_id_constraint_45 },
5597                 0, 0, /* No default value */
5598                 "id"
5599                 },
5600         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, criticality),
5601                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5602                 0,
5603                 &asn_DEF_Criticality,
5604                 select_RICsubscriptionDeleteFailure_IEs_criticality_type,
5605                 { &asn_OER_memb_criticality_constr_47, &asn_PER_memb_criticality_constr_47,  memb_criticality_constraint_45 },
5606                 0, 0, /* No default value */
5607                 "criticality"
5608                 },
5609         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, value),
5610                 -1 /* Ambiguous tag (ANY?) */,
5611                 0,
5612                 &asn_DEF_value_48,
5613                 select_RICsubscriptionDeleteFailure_IEs_value_type,
5614                 { &asn_OER_memb_value_constr_48, &asn_PER_memb_value_constr_48,  memb_value_constraint_45 },
5615                 0, 0, /* No default value */
5616                 "value"
5617                 },
5618 };
5619 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[] = {
5620         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5621 };
5622 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_45[] = {
5623     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5624     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5625 };
5626 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_45 = {
5627         sizeof(struct RICsubscriptionDeleteFailure_IEs),
5628         offsetof(struct RICsubscriptionDeleteFailure_IEs, _asn_ctx),
5629         asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_45,
5630         2,      /* Count of tags in the map */
5631         0, 0, 0,        /* Optional elements (not needed) */
5632         -1,     /* First extension addition */
5633 };
5634 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteFailure_IEs = {
5635         "RICsubscriptionDeleteFailure-IEs",
5636         "RICsubscriptionDeleteFailure-IEs",
5637         &asn_OP_SEQUENCE,
5638         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45,
5639         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45)
5640                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
5641         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45,       /* Same as above */
5642         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45)
5643                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
5644         { 0, 0, SEQUENCE_constraint },
5645         asn_MBR_RICsubscriptionDeleteFailure_IEs_45,
5646         3,      /* Elements count */
5647         &asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_45      /* Additional specs */
5648 };
5649
5650 static asn_TYPE_member_t asn_MBR_value_52[] = {
5651         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICrequestID),
5652                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5653                 0,
5654                 &asn_DEF_RICrequestID,
5655                 0,
5656                 { 0, 0, 0 },
5657                 0, 0, /* No default value */
5658                 "RICrequestID"
5659                 },
5660         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RANfunctionID),
5661                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5662                 0,
5663                 &asn_DEF_RANfunctionID,
5664                 0,
5665                 { 0, 0, 0 },
5666                 0, 0, /* No default value */
5667                 "RANfunctionID"
5668                 },
5669         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICactionID),
5670                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5671                 0,
5672                 &asn_DEF_RICactionID,
5673                 0,
5674                 { 0, 0, 0 },
5675                 0, 0, /* No default value */
5676                 "RICactionID"
5677                 },
5678         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationSN),
5679                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5680                 0,
5681                 &asn_DEF_RICindicationSN,
5682                 0,
5683                 { 0, 0, 0 },
5684                 0, 0, /* No default value */
5685                 "RICindicationSN"
5686                 },
5687         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationType),
5688                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5689                 0,
5690                 &asn_DEF_RICindicationType,
5691                 0,
5692                 { 0, 0, 0 },
5693                 0, 0, /* No default value */
5694                 "RICindicationType"
5695                 },
5696         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationHeader),
5697                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5698                 0,
5699                 &asn_DEF_RICindicationHeader,
5700                 0,
5701                 { 0, 0, 0 },
5702                 0, 0, /* No default value */
5703                 "RICindicationHeader"
5704                 },
5705         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationMessage),
5706                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5707                 0,
5708                 &asn_DEF_RICindicationMessage,
5709                 0,
5710                 { 0, 0, 0 },
5711                 0, 0, /* No default value */
5712                 "RICindicationMessage"
5713                 },
5714         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICcallProcessID),
5715                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5716                 0,
5717                 &asn_DEF_RICcallProcessID,
5718                 0,
5719                 { 0, 0, 0 },
5720                 0, 0, /* No default value */
5721                 "RICcallProcessID"
5722                 },
5723 };
5724 static const unsigned asn_MAP_value_to_canonical_52[] = { 1, 2, 3, 5, 6, 7, 4, 0 };
5725 static const unsigned asn_MAP_value_from_canonical_52[] = { 7, 0, 1, 2, 6, 3, 4, 5 };
5726 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_52[] = {
5727     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 2 }, /* RANfunctionID */
5728     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* RICactionID */
5729     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 0 }, /* RICindicationSN */
5730     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 5, 0, 2 }, /* RICindicationHeader */
5731     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 6, -1, 1 }, /* RICindicationMessage */
5732     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 7, -2, 0 }, /* RICcallProcessID */
5733     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* RICindicationType */
5734     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5735 };
5736 static asn_CHOICE_specifics_t asn_SPC_value_specs_52 = {
5737         sizeof(struct RICindication_IEs__value),
5738         offsetof(struct RICindication_IEs__value, _asn_ctx),
5739         offsetof(struct RICindication_IEs__value, present),
5740         sizeof(((struct RICindication_IEs__value *)0)->present),
5741         asn_MAP_value_tag2el_52,
5742         8,      /* Count of tags in the map */
5743         asn_MAP_value_to_canonical_52,
5744         asn_MAP_value_from_canonical_52,
5745         -1      /* Extensions start */
5746 };
5747 static /* Use -fall-defs-global to expose */
5748 asn_TYPE_descriptor_t asn_DEF_value_52 = {
5749         "value",
5750         "value",
5751         &asn_OP_OPEN_TYPE,
5752         0,      /* No effective tags (pointer) */
5753         0,      /* No effective tags (count) */
5754         0,      /* No tags (pointer) */
5755         0,      /* No tags (count) */
5756         { 0, 0, OPEN_TYPE_constraint },
5757         asn_MBR_value_52,
5758         8,      /* Elements count */
5759         &asn_SPC_value_specs_52 /* Additional specs */
5760 };
5761
5762 asn_TYPE_member_t asn_MBR_RICindication_IEs_49[] = {
5763         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, id),
5764                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5765                 0,
5766                 &asn_DEF_ProtocolIE_ID,
5767                 0,
5768                 { &asn_OER_memb_id_constr_50, &asn_PER_memb_id_constr_50,  memb_id_constraint_49 },
5769                 0, 0, /* No default value */
5770                 "id"
5771                 },
5772         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, criticality),
5773                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5774                 0,
5775                 &asn_DEF_Criticality,
5776                 select_RICindication_IEs_criticality_type,
5777                 { &asn_OER_memb_criticality_constr_51, &asn_PER_memb_criticality_constr_51,  memb_criticality_constraint_49 },
5778                 0, 0, /* No default value */
5779                 "criticality"
5780                 },
5781         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, value),
5782                 -1 /* Ambiguous tag (ANY?) */,
5783                 0,
5784                 &asn_DEF_value_52,
5785                 select_RICindication_IEs_value_type,
5786                 { &asn_OER_memb_value_constr_52, &asn_PER_memb_value_constr_52,  memb_value_constraint_49 },
5787                 0, 0, /* No default value */
5788                 "value"
5789                 },
5790 };
5791 static const ber_tlv_tag_t asn_DEF_RICindication_IEs_tags_49[] = {
5792         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5793 };
5794 static const asn_TYPE_tag2member_t asn_MAP_RICindication_IEs_tag2el_49[] = {
5795     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5796     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5797 };
5798 asn_SEQUENCE_specifics_t asn_SPC_RICindication_IEs_specs_49 = {
5799         sizeof(struct RICindication_IEs),
5800         offsetof(struct RICindication_IEs, _asn_ctx),
5801         asn_MAP_RICindication_IEs_tag2el_49,
5802         2,      /* Count of tags in the map */
5803         0, 0, 0,        /* Optional elements (not needed) */
5804         -1,     /* First extension addition */
5805 };
5806 asn_TYPE_descriptor_t asn_DEF_RICindication_IEs = {
5807         "RICindication-IEs",
5808         "RICindication-IEs",
5809         &asn_OP_SEQUENCE,
5810         asn_DEF_RICindication_IEs_tags_49,
5811         sizeof(asn_DEF_RICindication_IEs_tags_49)
5812                 /sizeof(asn_DEF_RICindication_IEs_tags_49[0]), /* 1 */
5813         asn_DEF_RICindication_IEs_tags_49,      /* Same as above */
5814         sizeof(asn_DEF_RICindication_IEs_tags_49)
5815                 /sizeof(asn_DEF_RICindication_IEs_tags_49[0]), /* 1 */
5816         { 0, 0, SEQUENCE_constraint },
5817         asn_MBR_RICindication_IEs_49,
5818         3,      /* Elements count */
5819         &asn_SPC_RICindication_IEs_specs_49     /* Additional specs */
5820 };
5821
5822 static asn_TYPE_member_t asn_MBR_value_56[] = {
5823         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICrequestID),
5824                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5825                 0,
5826                 &asn_DEF_RICrequestID,
5827                 0,
5828                 { 0, 0, 0 },
5829                 0, 0, /* No default value */
5830                 "RICrequestID"
5831                 },
5832         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RANfunctionID),
5833                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5834                 0,
5835                 &asn_DEF_RANfunctionID,
5836                 0,
5837                 { 0, 0, 0 },
5838                 0, 0, /* No default value */
5839                 "RANfunctionID"
5840                 },
5841         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcallProcessID),
5842                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5843                 0,
5844                 &asn_DEF_RICcallProcessID,
5845                 0,
5846                 { 0, 0, 0 },
5847                 0, 0, /* No default value */
5848                 "RICcallProcessID"
5849                 },
5850         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolHeader),
5851                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5852                 0,
5853                 &asn_DEF_RICcontrolHeader,
5854                 0,
5855                 { 0, 0, 0 },
5856                 0, 0, /* No default value */
5857                 "RICcontrolHeader"
5858                 },
5859         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolMessage),
5860                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5861                 0,
5862                 &asn_DEF_RICcontrolMessage,
5863                 0,
5864                 { 0, 0, 0 },
5865                 0, 0, /* No default value */
5866                 "RICcontrolMessage"
5867                 },
5868         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolAckRequest),
5869                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5870                 0,
5871                 &asn_DEF_RICcontrolAckRequest,
5872                 0,
5873                 { 0, 0, 0 },
5874                 0, 0, /* No default value */
5875                 "RICcontrolAckRequest"
5876                 },
5877 };
5878 static const unsigned asn_MAP_value_to_canonical_56[] = { 1, 2, 3, 4, 5, 0 };
5879 static const unsigned asn_MAP_value_from_canonical_56[] = { 5, 0, 1, 2, 3, 4 };
5880 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_56[] = {
5881     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5882     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 2 }, /* RICcallProcessID */
5883     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 1 }, /* RICcontrolHeader */
5884     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -2, 0 }, /* RICcontrolMessage */
5885     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 5, 0, 0 }, /* RICcontrolAckRequest */
5886     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5887 };
5888 static asn_CHOICE_specifics_t asn_SPC_value_specs_56 = {
5889         sizeof(struct RICcontrolRequest_IEs__value),
5890         offsetof(struct RICcontrolRequest_IEs__value, _asn_ctx),
5891         offsetof(struct RICcontrolRequest_IEs__value, present),
5892         sizeof(((struct RICcontrolRequest_IEs__value *)0)->present),
5893         asn_MAP_value_tag2el_56,
5894         6,      /* Count of tags in the map */
5895         asn_MAP_value_to_canonical_56,
5896         asn_MAP_value_from_canonical_56,
5897         -1      /* Extensions start */
5898 };
5899 static /* Use -fall-defs-global to expose */
5900 asn_TYPE_descriptor_t asn_DEF_value_56 = {
5901         "value",
5902         "value",
5903         &asn_OP_OPEN_TYPE,
5904         0,      /* No effective tags (pointer) */
5905         0,      /* No effective tags (count) */
5906         0,      /* No tags (pointer) */
5907         0,      /* No tags (count) */
5908         { 0, 0, OPEN_TYPE_constraint },
5909         asn_MBR_value_56,
5910         6,      /* Elements count */
5911         &asn_SPC_value_specs_56 /* Additional specs */
5912 };
5913
5914 asn_TYPE_member_t asn_MBR_RICcontrolRequest_IEs_53[] = {
5915         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, id),
5916                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5917                 0,
5918                 &asn_DEF_ProtocolIE_ID,
5919                 0,
5920                 { &asn_OER_memb_id_constr_54, &asn_PER_memb_id_constr_54,  memb_id_constraint_53 },
5921                 0, 0, /* No default value */
5922                 "id"
5923                 },
5924         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, criticality),
5925                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5926                 0,
5927                 &asn_DEF_Criticality,
5928                 select_RICcontrolRequest_IEs_criticality_type,
5929                 { &asn_OER_memb_criticality_constr_55, &asn_PER_memb_criticality_constr_55,  memb_criticality_constraint_53 },
5930                 0, 0, /* No default value */
5931                 "criticality"
5932                 },
5933         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, value),
5934                 -1 /* Ambiguous tag (ANY?) */,
5935                 0,
5936                 &asn_DEF_value_56,
5937                 select_RICcontrolRequest_IEs_value_type,
5938                 { &asn_OER_memb_value_constr_56, &asn_PER_memb_value_constr_56,  memb_value_constraint_53 },
5939                 0, 0, /* No default value */
5940                 "value"
5941                 },
5942 };
5943 static const ber_tlv_tag_t asn_DEF_RICcontrolRequest_IEs_tags_53[] = {
5944         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5945 };
5946 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolRequest_IEs_tag2el_53[] = {
5947     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
5948     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
5949 };
5950 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolRequest_IEs_specs_53 = {
5951         sizeof(struct RICcontrolRequest_IEs),
5952         offsetof(struct RICcontrolRequest_IEs, _asn_ctx),
5953         asn_MAP_RICcontrolRequest_IEs_tag2el_53,
5954         2,      /* Count of tags in the map */
5955         0, 0, 0,        /* Optional elements (not needed) */
5956         -1,     /* First extension addition */
5957 };
5958 asn_TYPE_descriptor_t asn_DEF_RICcontrolRequest_IEs = {
5959         "RICcontrolRequest-IEs",
5960         "RICcontrolRequest-IEs",
5961         &asn_OP_SEQUENCE,
5962         asn_DEF_RICcontrolRequest_IEs_tags_53,
5963         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53)
5964                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
5965         asn_DEF_RICcontrolRequest_IEs_tags_53,  /* Same as above */
5966         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53)
5967                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
5968         { 0, 0, SEQUENCE_constraint },
5969         asn_MBR_RICcontrolRequest_IEs_53,
5970         3,      /* Elements count */
5971         &asn_SPC_RICcontrolRequest_IEs_specs_53 /* Additional specs */
5972 };
5973
5974 static asn_TYPE_member_t asn_MBR_value_60[] = {
5975         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICrequestID),
5976                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5977                 0,
5978                 &asn_DEF_RICrequestID,
5979                 0,
5980                 { 0, 0, 0 },
5981                 0, 0, /* No default value */
5982                 "RICrequestID"
5983                 },
5984         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RANfunctionID),
5985                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5986                 0,
5987                 &asn_DEF_RANfunctionID,
5988                 0,
5989                 { 0, 0, 0 },
5990                 0, 0, /* No default value */
5991                 "RANfunctionID"
5992                 },
5993         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcallProcessID),
5994                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5995                 0,
5996                 &asn_DEF_RICcallProcessID,
5997                 0,
5998                 { 0, 0, 0 },
5999                 0, 0, /* No default value */
6000                 "RICcallProcessID"
6001                 },
6002         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolStatus),
6003                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6004                 0,
6005                 &asn_DEF_RICcontrolStatus,
6006                 0,
6007                 { 0, 0, 0 },
6008                 0, 0, /* No default value */
6009                 "RICcontrolStatus"
6010                 },
6011         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolOutcome),
6012                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
6013                 0,
6014                 &asn_DEF_RICcontrolOutcome,
6015                 0,
6016                 { 0, 0, 0 },
6017                 0, 0, /* No default value */
6018                 "RICcontrolOutcome"
6019                 },
6020 };
6021 static const unsigned asn_MAP_value_to_canonical_60[] = { 1, 2, 4, 3, 0 };
6022 static const unsigned asn_MAP_value_from_canonical_60[] = { 4, 0, 1, 3, 2 };
6023 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_60[] = {
6024     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6025     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
6026     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
6027     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 3, 0, 0 }, /* RICcontrolStatus */
6028     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
6029 };
6030 static asn_CHOICE_specifics_t asn_SPC_value_specs_60 = {
6031         sizeof(struct RICcontrolAcknowledge_IEs__value),
6032         offsetof(struct RICcontrolAcknowledge_IEs__value, _asn_ctx),
6033         offsetof(struct RICcontrolAcknowledge_IEs__value, present),
6034         sizeof(((struct RICcontrolAcknowledge_IEs__value *)0)->present),
6035         asn_MAP_value_tag2el_60,
6036         5,      /* Count of tags in the map */
6037         asn_MAP_value_to_canonical_60,
6038         asn_MAP_value_from_canonical_60,
6039         -1      /* Extensions start */
6040 };
6041 static /* Use -fall-defs-global to expose */
6042 asn_TYPE_descriptor_t asn_DEF_value_60 = {
6043         "value",
6044         "value",
6045         &asn_OP_OPEN_TYPE,
6046         0,      /* No effective tags (pointer) */
6047         0,      /* No effective tags (count) */
6048         0,      /* No tags (pointer) */
6049         0,      /* No tags (count) */
6050         { 0, 0, OPEN_TYPE_constraint },
6051         asn_MBR_value_60,
6052         5,      /* Elements count */
6053         &asn_SPC_value_specs_60 /* Additional specs */
6054 };
6055
6056 asn_TYPE_member_t asn_MBR_RICcontrolAcknowledge_IEs_57[] = {
6057         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, id),
6058                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6059                 0,
6060                 &asn_DEF_ProtocolIE_ID,
6061                 0,
6062                 { &asn_OER_memb_id_constr_58, &asn_PER_memb_id_constr_58,  memb_id_constraint_57 },
6063                 0, 0, /* No default value */
6064                 "id"
6065                 },
6066         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, criticality),
6067                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6068                 0,
6069                 &asn_DEF_Criticality,
6070                 select_RICcontrolAcknowledge_IEs_criticality_type,
6071                 { &asn_OER_memb_criticality_constr_59, &asn_PER_memb_criticality_constr_59,  memb_criticality_constraint_57 },
6072                 0, 0, /* No default value */
6073                 "criticality"
6074                 },
6075         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, value),
6076                 -1 /* Ambiguous tag (ANY?) */,
6077                 0,
6078                 &asn_DEF_value_60,
6079                 select_RICcontrolAcknowledge_IEs_value_type,
6080                 { &asn_OER_memb_value_constr_60, &asn_PER_memb_value_constr_60,  memb_value_constraint_57 },
6081                 0, 0, /* No default value */
6082                 "value"
6083                 },
6084 };
6085 static const ber_tlv_tag_t asn_DEF_RICcontrolAcknowledge_IEs_tags_57[] = {
6086         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6087 };
6088 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolAcknowledge_IEs_tag2el_57[] = {
6089     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6090     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6091 };
6092 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolAcknowledge_IEs_specs_57 = {
6093         sizeof(struct RICcontrolAcknowledge_IEs),
6094         offsetof(struct RICcontrolAcknowledge_IEs, _asn_ctx),
6095         asn_MAP_RICcontrolAcknowledge_IEs_tag2el_57,
6096         2,      /* Count of tags in the map */
6097         0, 0, 0,        /* Optional elements (not needed) */
6098         -1,     /* First extension addition */
6099 };
6100 asn_TYPE_descriptor_t asn_DEF_RICcontrolAcknowledge_IEs = {
6101         "RICcontrolAcknowledge-IEs",
6102         "RICcontrolAcknowledge-IEs",
6103         &asn_OP_SEQUENCE,
6104         asn_DEF_RICcontrolAcknowledge_IEs_tags_57,
6105         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57)
6106                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
6107         asn_DEF_RICcontrolAcknowledge_IEs_tags_57,      /* Same as above */
6108         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57)
6109                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
6110         { 0, 0, SEQUENCE_constraint },
6111         asn_MBR_RICcontrolAcknowledge_IEs_57,
6112         3,      /* Elements count */
6113         &asn_SPC_RICcontrolAcknowledge_IEs_specs_57     /* Additional specs */
6114 };
6115
6116 static asn_TYPE_member_t asn_MBR_value_64[] = {
6117         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICrequestID),
6118                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6119                 0,
6120                 &asn_DEF_RICrequestID,
6121                 0,
6122                 { 0, 0, 0 },
6123                 0, 0, /* No default value */
6124                 "RICrequestID"
6125                 },
6126         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RANfunctionID),
6127                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6128                 0,
6129                 &asn_DEF_RANfunctionID,
6130                 0,
6131                 { 0, 0, 0 },
6132                 0, 0, /* No default value */
6133                 "RANfunctionID"
6134                 },
6135         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcallProcessID),
6136                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
6137                 0,
6138                 &asn_DEF_RICcallProcessID,
6139                 0,
6140                 { 0, 0, 0 },
6141                 0, 0, /* No default value */
6142                 "RICcallProcessID"
6143                 },
6144         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.Cause),
6145                 -1 /* Ambiguous tag (CHOICE?) */,
6146                 0,
6147                 &asn_DEF_Cause,
6148                 0,
6149                 { 0, 0, 0 },
6150                 0, 0, /* No default value */
6151                 "Cause"
6152                 },
6153         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcontrolOutcome),
6154                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
6155                 0,
6156                 &asn_DEF_RICcontrolOutcome,
6157                 0,
6158                 { 0, 0, 0 },
6159                 0, 0, /* No default value */
6160                 "RICcontrolOutcome"
6161                 },
6162 };
6163 static const unsigned asn_MAP_value_to_canonical_64[] = { 1, 2, 4, 0, 3 };
6164 static const unsigned asn_MAP_value_from_canonical_64[] = { 3, 0, 1, 4, 2 };
6165 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_64[] = {
6166     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6167     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
6168     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
6169     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* RICrequestID */
6170     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 3, 0, 0 }, /* ricRequest */
6171     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* ricService */
6172     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 3, 0, 0 }, /* transport */
6173     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
6174     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* misc */
6175 };
6176 static asn_CHOICE_specifics_t asn_SPC_value_specs_64 = {
6177         sizeof(struct RICcontrolFailure_IEs__value),
6178         offsetof(struct RICcontrolFailure_IEs__value, _asn_ctx),
6179         offsetof(struct RICcontrolFailure_IEs__value, present),
6180         sizeof(((struct RICcontrolFailure_IEs__value *)0)->present),
6181         asn_MAP_value_tag2el_64,
6182         9,      /* Count of tags in the map */
6183         asn_MAP_value_to_canonical_64,
6184         asn_MAP_value_from_canonical_64,
6185         -1      /* Extensions start */
6186 };
6187 static /* Use -fall-defs-global to expose */
6188 asn_TYPE_descriptor_t asn_DEF_value_64 = {
6189         "value",
6190         "value",
6191         &asn_OP_OPEN_TYPE,
6192         0,      /* No effective tags (pointer) */
6193         0,      /* No effective tags (count) */
6194         0,      /* No tags (pointer) */
6195         0,      /* No tags (count) */
6196         { 0, 0, OPEN_TYPE_constraint },
6197         asn_MBR_value_64,
6198         5,      /* Elements count */
6199         &asn_SPC_value_specs_64 /* Additional specs */
6200 };
6201
6202 asn_TYPE_member_t asn_MBR_RICcontrolFailure_IEs_61[] = {
6203         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, id),
6204                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6205                 0,
6206                 &asn_DEF_ProtocolIE_ID,
6207                 0,
6208                 { &asn_OER_memb_id_constr_62, &asn_PER_memb_id_constr_62,  memb_id_constraint_61 },
6209                 0, 0, /* No default value */
6210                 "id"
6211                 },
6212         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, criticality),
6213                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6214                 0,
6215                 &asn_DEF_Criticality,
6216                 select_RICcontrolFailure_IEs_criticality_type,
6217                 { &asn_OER_memb_criticality_constr_63, &asn_PER_memb_criticality_constr_63,  memb_criticality_constraint_61 },
6218                 0, 0, /* No default value */
6219                 "criticality"
6220                 },
6221         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, value),
6222                 -1 /* Ambiguous tag (ANY?) */,
6223                 0,
6224                 &asn_DEF_value_64,
6225                 select_RICcontrolFailure_IEs_value_type,
6226                 { &asn_OER_memb_value_constr_64, &asn_PER_memb_value_constr_64,  memb_value_constraint_61 },
6227                 0, 0, /* No default value */
6228                 "value"
6229                 },
6230 };
6231 static const ber_tlv_tag_t asn_DEF_RICcontrolFailure_IEs_tags_61[] = {
6232         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6233 };
6234 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolFailure_IEs_tag2el_61[] = {
6235     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6236     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6237 };
6238 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolFailure_IEs_specs_61 = {
6239         sizeof(struct RICcontrolFailure_IEs),
6240         offsetof(struct RICcontrolFailure_IEs, _asn_ctx),
6241         asn_MAP_RICcontrolFailure_IEs_tag2el_61,
6242         2,      /* Count of tags in the map */
6243         0, 0, 0,        /* Optional elements (not needed) */
6244         -1,     /* First extension addition */
6245 };
6246 asn_TYPE_descriptor_t asn_DEF_RICcontrolFailure_IEs = {
6247         "RICcontrolFailure-IEs",
6248         "RICcontrolFailure-IEs",
6249         &asn_OP_SEQUENCE,
6250         asn_DEF_RICcontrolFailure_IEs_tags_61,
6251         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61)
6252                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
6253         asn_DEF_RICcontrolFailure_IEs_tags_61,  /* Same as above */
6254         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61)
6255                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
6256         { 0, 0, SEQUENCE_constraint },
6257         asn_MBR_RICcontrolFailure_IEs_61,
6258         3,      /* Elements count */
6259         &asn_SPC_RICcontrolFailure_IEs_specs_61 /* Additional specs */
6260 };
6261
6262 static asn_TYPE_member_t asn_MBR_value_68[] = {
6263         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RICrequestID),
6264                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6265                 0,
6266                 &asn_DEF_RICrequestID,
6267                 0,
6268                 { 0, 0, 0 },
6269                 0, 0, /* No default value */
6270                 "RICrequestID"
6271                 },
6272         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RANfunctionID),
6273                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6274                 0,
6275                 &asn_DEF_RANfunctionID,
6276                 0,
6277                 { 0, 0, 0 },
6278                 0, 0, /* No default value */
6279                 "RANfunctionID"
6280                 },
6281         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.Cause),
6282                 -1 /* Ambiguous tag (CHOICE?) */,
6283                 0,
6284                 &asn_DEF_Cause,
6285                 0,
6286                 { 0, 0, 0 },
6287                 0, 0, /* No default value */
6288                 "Cause"
6289                 },
6290         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.CriticalityDiagnostics),
6291                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6292                 0,
6293                 &asn_DEF_CriticalityDiagnostics,
6294                 0,
6295                 { 0, 0, 0 },
6296                 0, 0, /* No default value */
6297                 "CriticalityDiagnostics"
6298                 },
6299 };
6300 static const unsigned asn_MAP_value_to_canonical_68[] = { 1, 0, 3, 2 };
6301 static const unsigned asn_MAP_value_from_canonical_68[] = { 1, 0, 3, 2 };
6302 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_68[] = {
6303     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6304     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
6305     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
6306     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
6307     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
6308     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
6309     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
6310     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
6311 };
6312 static asn_CHOICE_specifics_t asn_SPC_value_specs_68 = {
6313         sizeof(struct ErrorIndication_IEs__value),
6314         offsetof(struct ErrorIndication_IEs__value, _asn_ctx),
6315         offsetof(struct ErrorIndication_IEs__value, present),
6316         sizeof(((struct ErrorIndication_IEs__value *)0)->present),
6317         asn_MAP_value_tag2el_68,
6318         8,      /* Count of tags in the map */
6319         asn_MAP_value_to_canonical_68,
6320         asn_MAP_value_from_canonical_68,
6321         -1      /* Extensions start */
6322 };
6323 static /* Use -fall-defs-global to expose */
6324 asn_TYPE_descriptor_t asn_DEF_value_68 = {
6325         "value",
6326         "value",
6327         &asn_OP_OPEN_TYPE,
6328         0,      /* No effective tags (pointer) */
6329         0,      /* No effective tags (count) */
6330         0,      /* No tags (pointer) */
6331         0,      /* No tags (count) */
6332         { 0, 0, OPEN_TYPE_constraint },
6333         asn_MBR_value_68,
6334         4,      /* Elements count */
6335         &asn_SPC_value_specs_68 /* Additional specs */
6336 };
6337
6338 asn_TYPE_member_t asn_MBR_ErrorIndication_IEs_65[] = {
6339         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, id),
6340                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6341                 0,
6342                 &asn_DEF_ProtocolIE_ID,
6343                 0,
6344                 { &asn_OER_memb_id_constr_66, &asn_PER_memb_id_constr_66,  memb_id_constraint_65 },
6345                 0, 0, /* No default value */
6346                 "id"
6347                 },
6348         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, criticality),
6349                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6350                 0,
6351                 &asn_DEF_Criticality,
6352                 select_ErrorIndication_IEs_criticality_type,
6353                 { &asn_OER_memb_criticality_constr_67, &asn_PER_memb_criticality_constr_67,  memb_criticality_constraint_65 },
6354                 0, 0, /* No default value */
6355                 "criticality"
6356                 },
6357         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, value),
6358                 -1 /* Ambiguous tag (ANY?) */,
6359                 0,
6360                 &asn_DEF_value_68,
6361                 select_ErrorIndication_IEs_value_type,
6362                 { &asn_OER_memb_value_constr_68, &asn_PER_memb_value_constr_68,  memb_value_constraint_65 },
6363                 0, 0, /* No default value */
6364                 "value"
6365                 },
6366 };
6367 static const ber_tlv_tag_t asn_DEF_ErrorIndication_IEs_tags_65[] = {
6368         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6369 };
6370 static const asn_TYPE_tag2member_t asn_MAP_ErrorIndication_IEs_tag2el_65[] = {
6371     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6372     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6373 };
6374 asn_SEQUENCE_specifics_t asn_SPC_ErrorIndication_IEs_specs_65 = {
6375         sizeof(struct ErrorIndication_IEs),
6376         offsetof(struct ErrorIndication_IEs, _asn_ctx),
6377         asn_MAP_ErrorIndication_IEs_tag2el_65,
6378         2,      /* Count of tags in the map */
6379         0, 0, 0,        /* Optional elements (not needed) */
6380         -1,     /* First extension addition */
6381 };
6382 asn_TYPE_descriptor_t asn_DEF_ErrorIndication_IEs = {
6383         "ErrorIndication-IEs",
6384         "ErrorIndication-IEs",
6385         &asn_OP_SEQUENCE,
6386         asn_DEF_ErrorIndication_IEs_tags_65,
6387         sizeof(asn_DEF_ErrorIndication_IEs_tags_65)
6388                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_65[0]), /* 1 */
6389         asn_DEF_ErrorIndication_IEs_tags_65,    /* Same as above */
6390         sizeof(asn_DEF_ErrorIndication_IEs_tags_65)
6391                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_65[0]), /* 1 */
6392         { 0, 0, SEQUENCE_constraint },
6393         asn_MBR_ErrorIndication_IEs_65,
6394         3,      /* Elements count */
6395         &asn_SPC_ErrorIndication_IEs_specs_65   /* Additional specs */
6396 };
6397
6398 static asn_TYPE_member_t asn_MBR_value_72[] = {
6399         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.GlobalE2node_ID),
6400                 -1 /* Ambiguous tag (CHOICE?) */,
6401                 0,
6402                 &asn_DEF_GlobalE2node_ID,
6403                 0,
6404                 { 0, 0, 0 },
6405                 0, 0, /* No default value */
6406                 "GlobalE2node-ID"
6407                 },
6408         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.RANfunctions_List),
6409                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6410                 0,
6411                 &asn_DEF_RANfunctions_List,
6412                 0,
6413                 { 0, 0, 0 },
6414                 0, 0, /* No default value */
6415                 "RANfunctions-List"
6416                 },
6417 };
6418 static const unsigned asn_MAP_value_to_canonical_72[] = { 1, 0 };
6419 static const unsigned asn_MAP_value_from_canonical_72[] = { 1, 0 };
6420 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_72[] = {
6421     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* RANfunctions-List */
6422     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gNB */
6423     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* en-gNB */
6424     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* ng-eNB */
6425     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 } /* eNB */
6426 };
6427 static asn_CHOICE_specifics_t asn_SPC_value_specs_72 = {
6428         sizeof(struct E2setupRequestIEs__value),
6429         offsetof(struct E2setupRequestIEs__value, _asn_ctx),
6430         offsetof(struct E2setupRequestIEs__value, present),
6431         sizeof(((struct E2setupRequestIEs__value *)0)->present),
6432         asn_MAP_value_tag2el_72,
6433         5,      /* Count of tags in the map */
6434         asn_MAP_value_to_canonical_72,
6435         asn_MAP_value_from_canonical_72,
6436         -1      /* Extensions start */
6437 };
6438 static /* Use -fall-defs-global to expose */
6439 asn_TYPE_descriptor_t asn_DEF_value_72 = {
6440         "value",
6441         "value",
6442         &asn_OP_OPEN_TYPE,
6443         0,      /* No effective tags (pointer) */
6444         0,      /* No effective tags (count) */
6445         0,      /* No tags (pointer) */
6446         0,      /* No tags (count) */
6447         { 0, 0, OPEN_TYPE_constraint },
6448         asn_MBR_value_72,
6449         2,      /* Elements count */
6450         &asn_SPC_value_specs_72 /* Additional specs */
6451 };
6452
6453 asn_TYPE_member_t asn_MBR_E2setupRequestIEs_69[] = {
6454         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, id),
6455                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6456                 0,
6457                 &asn_DEF_ProtocolIE_ID,
6458                 0,
6459                 { &asn_OER_memb_id_constr_70, &asn_PER_memb_id_constr_70,  memb_id_constraint_69 },
6460                 0, 0, /* No default value */
6461                 "id"
6462                 },
6463         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, criticality),
6464                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6465                 0,
6466                 &asn_DEF_Criticality,
6467                 select_E2setupRequestIEs_criticality_type,
6468                 { &asn_OER_memb_criticality_constr_71, &asn_PER_memb_criticality_constr_71,  memb_criticality_constraint_69 },
6469                 0, 0, /* No default value */
6470                 "criticality"
6471                 },
6472         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, value),
6473                 -1 /* Ambiguous tag (ANY?) */,
6474                 0,
6475                 &asn_DEF_value_72,
6476                 select_E2setupRequestIEs_value_type,
6477                 { &asn_OER_memb_value_constr_72, &asn_PER_memb_value_constr_72,  memb_value_constraint_69 },
6478                 0, 0, /* No default value */
6479                 "value"
6480                 },
6481 };
6482 static const ber_tlv_tag_t asn_DEF_E2setupRequestIEs_tags_69[] = {
6483         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6484 };
6485 static const asn_TYPE_tag2member_t asn_MAP_E2setupRequestIEs_tag2el_69[] = {
6486     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6487     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6488 };
6489 asn_SEQUENCE_specifics_t asn_SPC_E2setupRequestIEs_specs_69 = {
6490         sizeof(struct E2setupRequestIEs),
6491         offsetof(struct E2setupRequestIEs, _asn_ctx),
6492         asn_MAP_E2setupRequestIEs_tag2el_69,
6493         2,      /* Count of tags in the map */
6494         0, 0, 0,        /* Optional elements (not needed) */
6495         -1,     /* First extension addition */
6496 };
6497 asn_TYPE_descriptor_t asn_DEF_E2setupRequestIEs = {
6498         "E2setupRequestIEs",
6499         "E2setupRequestIEs",
6500         &asn_OP_SEQUENCE,
6501         asn_DEF_E2setupRequestIEs_tags_69,
6502         sizeof(asn_DEF_E2setupRequestIEs_tags_69)
6503                 /sizeof(asn_DEF_E2setupRequestIEs_tags_69[0]), /* 1 */
6504         asn_DEF_E2setupRequestIEs_tags_69,      /* Same as above */
6505         sizeof(asn_DEF_E2setupRequestIEs_tags_69)
6506                 /sizeof(asn_DEF_E2setupRequestIEs_tags_69[0]), /* 1 */
6507         { 0, 0, SEQUENCE_constraint },
6508         asn_MBR_E2setupRequestIEs_69,
6509         3,      /* Elements count */
6510         &asn_SPC_E2setupRequestIEs_specs_69     /* Additional specs */
6511 };
6512
6513 static asn_TYPE_member_t asn_MBR_value_76[] = {
6514         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.GlobalRIC_ID),
6515                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6516                 0,
6517                 &asn_DEF_GlobalRIC_ID,
6518                 0,
6519                 { 0, 0, 0 },
6520                 0, 0, /* No default value */
6521                 "GlobalRIC-ID"
6522                 },
6523         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsID_List),
6524                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6525                 0,
6526                 &asn_DEF_RANfunctionsID_List,
6527                 0,
6528                 { 0, 0, 0 },
6529                 0, 0, /* No default value */
6530                 "RANfunctionsID-List"
6531                 },
6532         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsIDcause_List),
6533                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6534                 0,
6535                 &asn_DEF_RANfunctionsIDcause_List,
6536                 0,
6537                 { 0, 0, 0 },
6538                 0, 0, /* No default value */
6539                 "RANfunctionsIDcause-List"
6540                 },
6541 };
6542 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_76[] = {
6543     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* GlobalRIC-ID */
6544     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 1 }, /* RANfunctionsID-List */
6545     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -2, 0 } /* RANfunctionsIDcause-List */
6546 };
6547 static asn_CHOICE_specifics_t asn_SPC_value_specs_76 = {
6548         sizeof(struct E2setupResponseIEs__value),
6549         offsetof(struct E2setupResponseIEs__value, _asn_ctx),
6550         offsetof(struct E2setupResponseIEs__value, present),
6551         sizeof(((struct E2setupResponseIEs__value *)0)->present),
6552         asn_MAP_value_tag2el_76,
6553         3,      /* Count of tags in the map */
6554         0, 0,
6555         -1      /* Extensions start */
6556 };
6557 static /* Use -fall-defs-global to expose */
6558 asn_TYPE_descriptor_t asn_DEF_value_76 = {
6559         "value",
6560         "value",
6561         &asn_OP_OPEN_TYPE,
6562         0,      /* No effective tags (pointer) */
6563         0,      /* No effective tags (count) */
6564         0,      /* No tags (pointer) */
6565         0,      /* No tags (count) */
6566         { 0, 0, OPEN_TYPE_constraint },
6567         asn_MBR_value_76,
6568         3,      /* Elements count */
6569         &asn_SPC_value_specs_76 /* Additional specs */
6570 };
6571
6572 asn_TYPE_member_t asn_MBR_E2setupResponseIEs_73[] = {
6573         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, id),
6574                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6575                 0,
6576                 &asn_DEF_ProtocolIE_ID,
6577                 0,
6578                 { &asn_OER_memb_id_constr_74, &asn_PER_memb_id_constr_74,  memb_id_constraint_73 },
6579                 0, 0, /* No default value */
6580                 "id"
6581                 },
6582         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, criticality),
6583                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6584                 0,
6585                 &asn_DEF_Criticality,
6586                 select_E2setupResponseIEs_criticality_type,
6587                 { &asn_OER_memb_criticality_constr_75, &asn_PER_memb_criticality_constr_75,  memb_criticality_constraint_73 },
6588                 0, 0, /* No default value */
6589                 "criticality"
6590                 },
6591         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, value),
6592                 -1 /* Ambiguous tag (ANY?) */,
6593                 0,
6594                 &asn_DEF_value_76,
6595                 select_E2setupResponseIEs_value_type,
6596                 { &asn_OER_memb_value_constr_76, &asn_PER_memb_value_constr_76,  memb_value_constraint_73 },
6597                 0, 0, /* No default value */
6598                 "value"
6599                 },
6600 };
6601 static const ber_tlv_tag_t asn_DEF_E2setupResponseIEs_tags_73[] = {
6602         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6603 };
6604 static const asn_TYPE_tag2member_t asn_MAP_E2setupResponseIEs_tag2el_73[] = {
6605     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6606     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6607 };
6608 asn_SEQUENCE_specifics_t asn_SPC_E2setupResponseIEs_specs_73 = {
6609         sizeof(struct E2setupResponseIEs),
6610         offsetof(struct E2setupResponseIEs, _asn_ctx),
6611         asn_MAP_E2setupResponseIEs_tag2el_73,
6612         2,      /* Count of tags in the map */
6613         0, 0, 0,        /* Optional elements (not needed) */
6614         -1,     /* First extension addition */
6615 };
6616 asn_TYPE_descriptor_t asn_DEF_E2setupResponseIEs = {
6617         "E2setupResponseIEs",
6618         "E2setupResponseIEs",
6619         &asn_OP_SEQUENCE,
6620         asn_DEF_E2setupResponseIEs_tags_73,
6621         sizeof(asn_DEF_E2setupResponseIEs_tags_73)
6622                 /sizeof(asn_DEF_E2setupResponseIEs_tags_73[0]), /* 1 */
6623         asn_DEF_E2setupResponseIEs_tags_73,     /* Same as above */
6624         sizeof(asn_DEF_E2setupResponseIEs_tags_73)
6625                 /sizeof(asn_DEF_E2setupResponseIEs_tags_73[0]), /* 1 */
6626         { 0, 0, SEQUENCE_constraint },
6627         asn_MBR_E2setupResponseIEs_73,
6628         3,      /* Elements count */
6629         &asn_SPC_E2setupResponseIEs_specs_73    /* Additional specs */
6630 };
6631
6632 static asn_TYPE_member_t asn_MBR_value_80[] = {
6633         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.Cause),
6634                 -1 /* Ambiguous tag (CHOICE?) */,
6635                 0,
6636                 &asn_DEF_Cause,
6637                 0,
6638                 { 0, 0, 0 },
6639                 0, 0, /* No default value */
6640                 "Cause"
6641                 },
6642         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.TimeToWait),
6643                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6644                 0,
6645                 &asn_DEF_TimeToWait,
6646                 0,
6647                 { 0, 0, 0 },
6648                 0, 0, /* No default value */
6649                 "TimeToWait"
6650                 },
6651         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.CriticalityDiagnostics),
6652                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6653                 0,
6654                 &asn_DEF_CriticalityDiagnostics,
6655                 0,
6656                 { 0, 0, 0 },
6657                 0, 0, /* No default value */
6658                 "CriticalityDiagnostics"
6659                 },
6660 };
6661 static const unsigned asn_MAP_value_to_canonical_80[] = { 1, 2, 0 };
6662 static const unsigned asn_MAP_value_from_canonical_80[] = { 2, 0, 1 };
6663 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_80[] = {
6664     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
6665     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 }, /* CriticalityDiagnostics */
6666     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
6667     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
6668     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
6669     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
6670     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
6671 };
6672 static asn_CHOICE_specifics_t asn_SPC_value_specs_80 = {
6673         sizeof(struct E2setupFailureIEs__value),
6674         offsetof(struct E2setupFailureIEs__value, _asn_ctx),
6675         offsetof(struct E2setupFailureIEs__value, present),
6676         sizeof(((struct E2setupFailureIEs__value *)0)->present),
6677         asn_MAP_value_tag2el_80,
6678         7,      /* Count of tags in the map */
6679         asn_MAP_value_to_canonical_80,
6680         asn_MAP_value_from_canonical_80,
6681         -1      /* Extensions start */
6682 };
6683 static /* Use -fall-defs-global to expose */
6684 asn_TYPE_descriptor_t asn_DEF_value_80 = {
6685         "value",
6686         "value",
6687         &asn_OP_OPEN_TYPE,
6688         0,      /* No effective tags (pointer) */
6689         0,      /* No effective tags (count) */
6690         0,      /* No tags (pointer) */
6691         0,      /* No tags (count) */
6692         { 0, 0, OPEN_TYPE_constraint },
6693         asn_MBR_value_80,
6694         3,      /* Elements count */
6695         &asn_SPC_value_specs_80 /* Additional specs */
6696 };
6697
6698 asn_TYPE_member_t asn_MBR_E2setupFailureIEs_77[] = {
6699         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, id),
6700                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6701                 0,
6702                 &asn_DEF_ProtocolIE_ID,
6703                 0,
6704                 { &asn_OER_memb_id_constr_78, &asn_PER_memb_id_constr_78,  memb_id_constraint_77 },
6705                 0, 0, /* No default value */
6706                 "id"
6707                 },
6708         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, criticality),
6709                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6710                 0,
6711                 &asn_DEF_Criticality,
6712                 select_E2setupFailureIEs_criticality_type,
6713                 { &asn_OER_memb_criticality_constr_79, &asn_PER_memb_criticality_constr_79,  memb_criticality_constraint_77 },
6714                 0, 0, /* No default value */
6715                 "criticality"
6716                 },
6717         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, value),
6718                 -1 /* Ambiguous tag (ANY?) */,
6719                 0,
6720                 &asn_DEF_value_80,
6721                 select_E2setupFailureIEs_value_type,
6722                 { &asn_OER_memb_value_constr_80, &asn_PER_memb_value_constr_80,  memb_value_constraint_77 },
6723                 0, 0, /* No default value */
6724                 "value"
6725                 },
6726 };
6727 static const ber_tlv_tag_t asn_DEF_E2setupFailureIEs_tags_77[] = {
6728         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6729 };
6730 static const asn_TYPE_tag2member_t asn_MAP_E2setupFailureIEs_tag2el_77[] = {
6731     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6732     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6733 };
6734 asn_SEQUENCE_specifics_t asn_SPC_E2setupFailureIEs_specs_77 = {
6735         sizeof(struct E2setupFailureIEs),
6736         offsetof(struct E2setupFailureIEs, _asn_ctx),
6737         asn_MAP_E2setupFailureIEs_tag2el_77,
6738         2,      /* Count of tags in the map */
6739         0, 0, 0,        /* Optional elements (not needed) */
6740         -1,     /* First extension addition */
6741 };
6742 asn_TYPE_descriptor_t asn_DEF_E2setupFailureIEs = {
6743         "E2setupFailureIEs",
6744         "E2setupFailureIEs",
6745         &asn_OP_SEQUENCE,
6746         asn_DEF_E2setupFailureIEs_tags_77,
6747         sizeof(asn_DEF_E2setupFailureIEs_tags_77)
6748                 /sizeof(asn_DEF_E2setupFailureIEs_tags_77[0]), /* 1 */
6749         asn_DEF_E2setupFailureIEs_tags_77,      /* Same as above */
6750         sizeof(asn_DEF_E2setupFailureIEs_tags_77)
6751                 /sizeof(asn_DEF_E2setupFailureIEs_tags_77[0]), /* 1 */
6752         { 0, 0, SEQUENCE_constraint },
6753         asn_MBR_E2setupFailureIEs_77,
6754         3,      /* Elements count */
6755         &asn_SPC_E2setupFailureIEs_specs_77     /* Additional specs */
6756 };
6757
6758 static asn_TYPE_member_t asn_MBR_value_84[] = {
6759         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs__value, choice.Cause),
6760                 -1 /* Ambiguous tag (CHOICE?) */,
6761                 0,
6762                 &asn_DEF_Cause,
6763                 0,
6764                 { 0, 0, 0 },
6765                 0, 0, /* No default value */
6766                 "Cause"
6767                 },
6768 };
6769 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_84[] = {
6770     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
6771     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
6772     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
6773     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
6774     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
6775 };
6776 static asn_CHOICE_specifics_t asn_SPC_value_specs_84 = {
6777         sizeof(struct ResetRequestIEs__value),
6778         offsetof(struct ResetRequestIEs__value, _asn_ctx),
6779         offsetof(struct ResetRequestIEs__value, present),
6780         sizeof(((struct ResetRequestIEs__value *)0)->present),
6781         asn_MAP_value_tag2el_84,
6782         5,      /* Count of tags in the map */
6783         0, 0,
6784         -1      /* Extensions start */
6785 };
6786 static /* Use -fall-defs-global to expose */
6787 asn_TYPE_descriptor_t asn_DEF_value_84 = {
6788         "value",
6789         "value",
6790         &asn_OP_OPEN_TYPE,
6791         0,      /* No effective tags (pointer) */
6792         0,      /* No effective tags (count) */
6793         0,      /* No tags (pointer) */
6794         0,      /* No tags (count) */
6795         { 0, 0, OPEN_TYPE_constraint },
6796         asn_MBR_value_84,
6797         1,      /* Elements count */
6798         &asn_SPC_value_specs_84 /* Additional specs */
6799 };
6800
6801 asn_TYPE_member_t asn_MBR_ResetRequestIEs_81[] = {
6802         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, id),
6803                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6804                 0,
6805                 &asn_DEF_ProtocolIE_ID,
6806                 0,
6807                 { &asn_OER_memb_id_constr_82, &asn_PER_memb_id_constr_82,  memb_id_constraint_81 },
6808                 0, 0, /* No default value */
6809                 "id"
6810                 },
6811         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, criticality),
6812                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6813                 0,
6814                 &asn_DEF_Criticality,
6815                 select_ResetRequestIEs_criticality_type,
6816                 { &asn_OER_memb_criticality_constr_83, &asn_PER_memb_criticality_constr_83,  memb_criticality_constraint_81 },
6817                 0, 0, /* No default value */
6818                 "criticality"
6819                 },
6820         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, value),
6821                 -1 /* Ambiguous tag (ANY?) */,
6822                 0,
6823                 &asn_DEF_value_84,
6824                 select_ResetRequestIEs_value_type,
6825                 { &asn_OER_memb_value_constr_84, &asn_PER_memb_value_constr_84,  memb_value_constraint_81 },
6826                 0, 0, /* No default value */
6827                 "value"
6828                 },
6829 };
6830 static const ber_tlv_tag_t asn_DEF_ResetRequestIEs_tags_81[] = {
6831         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6832 };
6833 static const asn_TYPE_tag2member_t asn_MAP_ResetRequestIEs_tag2el_81[] = {
6834     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6835     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6836 };
6837 asn_SEQUENCE_specifics_t asn_SPC_ResetRequestIEs_specs_81 = {
6838         sizeof(struct ResetRequestIEs),
6839         offsetof(struct ResetRequestIEs, _asn_ctx),
6840         asn_MAP_ResetRequestIEs_tag2el_81,
6841         2,      /* Count of tags in the map */
6842         0, 0, 0,        /* Optional elements (not needed) */
6843         -1,     /* First extension addition */
6844 };
6845 asn_TYPE_descriptor_t asn_DEF_ResetRequestIEs = {
6846         "ResetRequestIEs",
6847         "ResetRequestIEs",
6848         &asn_OP_SEQUENCE,
6849         asn_DEF_ResetRequestIEs_tags_81,
6850         sizeof(asn_DEF_ResetRequestIEs_tags_81)
6851                 /sizeof(asn_DEF_ResetRequestIEs_tags_81[0]), /* 1 */
6852         asn_DEF_ResetRequestIEs_tags_81,        /* Same as above */
6853         sizeof(asn_DEF_ResetRequestIEs_tags_81)
6854                 /sizeof(asn_DEF_ResetRequestIEs_tags_81[0]), /* 1 */
6855         { 0, 0, SEQUENCE_constraint },
6856         asn_MBR_ResetRequestIEs_81,
6857         3,      /* Elements count */
6858         &asn_SPC_ResetRequestIEs_specs_81       /* Additional specs */
6859 };
6860
6861 static asn_TYPE_member_t asn_MBR_value_88[] = {
6862         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs__value, choice.CriticalityDiagnostics),
6863                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6864                 0,
6865                 &asn_DEF_CriticalityDiagnostics,
6866                 0,
6867                 { 0, 0, 0 },
6868                 0, 0, /* No default value */
6869                 "CriticalityDiagnostics"
6870                 },
6871 };
6872 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_88[] = {
6873     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* CriticalityDiagnostics */
6874 };
6875 static asn_CHOICE_specifics_t asn_SPC_value_specs_88 = {
6876         sizeof(struct ResetResponseIEs__value),
6877         offsetof(struct ResetResponseIEs__value, _asn_ctx),
6878         offsetof(struct ResetResponseIEs__value, present),
6879         sizeof(((struct ResetResponseIEs__value *)0)->present),
6880         asn_MAP_value_tag2el_88,
6881         1,      /* Count of tags in the map */
6882         0, 0,
6883         -1      /* Extensions start */
6884 };
6885 static /* Use -fall-defs-global to expose */
6886 asn_TYPE_descriptor_t asn_DEF_value_88 = {
6887         "value",
6888         "value",
6889         &asn_OP_OPEN_TYPE,
6890         0,      /* No effective tags (pointer) */
6891         0,      /* No effective tags (count) */
6892         0,      /* No tags (pointer) */
6893         0,      /* No tags (count) */
6894         { 0, 0, OPEN_TYPE_constraint },
6895         asn_MBR_value_88,
6896         1,      /* Elements count */
6897         &asn_SPC_value_specs_88 /* Additional specs */
6898 };
6899
6900 asn_TYPE_member_t asn_MBR_ResetResponseIEs_85[] = {
6901         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, id),
6902                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6903                 0,
6904                 &asn_DEF_ProtocolIE_ID,
6905                 0,
6906                 { &asn_OER_memb_id_constr_86, &asn_PER_memb_id_constr_86,  memb_id_constraint_85 },
6907                 0, 0, /* No default value */
6908                 "id"
6909                 },
6910         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, criticality),
6911                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6912                 0,
6913                 &asn_DEF_Criticality,
6914                 select_ResetResponseIEs_criticality_type,
6915                 { &asn_OER_memb_criticality_constr_87, &asn_PER_memb_criticality_constr_87,  memb_criticality_constraint_85 },
6916                 0, 0, /* No default value */
6917                 "criticality"
6918                 },
6919         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, value),
6920                 -1 /* Ambiguous tag (ANY?) */,
6921                 0,
6922                 &asn_DEF_value_88,
6923                 select_ResetResponseIEs_value_type,
6924                 { &asn_OER_memb_value_constr_88, &asn_PER_memb_value_constr_88,  memb_value_constraint_85 },
6925                 0, 0, /* No default value */
6926                 "value"
6927                 },
6928 };
6929 static const ber_tlv_tag_t asn_DEF_ResetResponseIEs_tags_85[] = {
6930         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6931 };
6932 static const asn_TYPE_tag2member_t asn_MAP_ResetResponseIEs_tag2el_85[] = {
6933     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
6934     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
6935 };
6936 asn_SEQUENCE_specifics_t asn_SPC_ResetResponseIEs_specs_85 = {
6937         sizeof(struct ResetResponseIEs),
6938         offsetof(struct ResetResponseIEs, _asn_ctx),
6939         asn_MAP_ResetResponseIEs_tag2el_85,
6940         2,      /* Count of tags in the map */
6941         0, 0, 0,        /* Optional elements (not needed) */
6942         -1,     /* First extension addition */
6943 };
6944 asn_TYPE_descriptor_t asn_DEF_ResetResponseIEs = {
6945         "ResetResponseIEs",
6946         "ResetResponseIEs",
6947         &asn_OP_SEQUENCE,
6948         asn_DEF_ResetResponseIEs_tags_85,
6949         sizeof(asn_DEF_ResetResponseIEs_tags_85)
6950                 /sizeof(asn_DEF_ResetResponseIEs_tags_85[0]), /* 1 */
6951         asn_DEF_ResetResponseIEs_tags_85,       /* Same as above */
6952         sizeof(asn_DEF_ResetResponseIEs_tags_85)
6953                 /sizeof(asn_DEF_ResetResponseIEs_tags_85[0]), /* 1 */
6954         { 0, 0, SEQUENCE_constraint },
6955         asn_MBR_ResetResponseIEs_85,
6956         3,      /* Elements count */
6957         &asn_SPC_ResetResponseIEs_specs_85      /* Additional specs */
6958 };
6959
6960 static asn_TYPE_member_t asn_MBR_value_92[] = {
6961         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctions_List),
6962                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6963                 0,
6964                 &asn_DEF_RANfunctions_List,
6965                 0,
6966                 { 0, 0, 0 },
6967                 0, 0, /* No default value */
6968                 "RANfunctions-List"
6969                 },
6970         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctionsID_List),
6971                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6972                 0,
6973                 &asn_DEF_RANfunctionsID_List,
6974                 0,
6975                 { 0, 0, 0 },
6976                 0, 0, /* No default value */
6977                 "RANfunctionsID-List"
6978                 },
6979 };
6980 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_92[] = {
6981     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctions-List */
6982     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsID-List */
6983 };
6984 static asn_CHOICE_specifics_t asn_SPC_value_specs_92 = {
6985         sizeof(struct RICserviceUpdate_IEs__value),
6986         offsetof(struct RICserviceUpdate_IEs__value, _asn_ctx),
6987         offsetof(struct RICserviceUpdate_IEs__value, present),
6988         sizeof(((struct RICserviceUpdate_IEs__value *)0)->present),
6989         asn_MAP_value_tag2el_92,
6990         2,      /* Count of tags in the map */
6991         0, 0,
6992         -1      /* Extensions start */
6993 };
6994 static /* Use -fall-defs-global to expose */
6995 asn_TYPE_descriptor_t asn_DEF_value_92 = {
6996         "value",
6997         "value",
6998         &asn_OP_OPEN_TYPE,
6999         0,      /* No effective tags (pointer) */
7000         0,      /* No effective tags (count) */
7001         0,      /* No tags (pointer) */
7002         0,      /* No tags (count) */
7003         { 0, 0, OPEN_TYPE_constraint },
7004         asn_MBR_value_92,
7005         2,      /* Elements count */
7006         &asn_SPC_value_specs_92 /* Additional specs */
7007 };
7008
7009 asn_TYPE_member_t asn_MBR_RICserviceUpdate_IEs_89[] = {
7010         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, id),
7011                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7012                 0,
7013                 &asn_DEF_ProtocolIE_ID,
7014                 0,
7015                 { &asn_OER_memb_id_constr_90, &asn_PER_memb_id_constr_90,  memb_id_constraint_89 },
7016                 0, 0, /* No default value */
7017                 "id"
7018                 },
7019         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, criticality),
7020                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7021                 0,
7022                 &asn_DEF_Criticality,
7023                 select_RICserviceUpdate_IEs_criticality_type,
7024                 { &asn_OER_memb_criticality_constr_91, &asn_PER_memb_criticality_constr_91,  memb_criticality_constraint_89 },
7025                 0, 0, /* No default value */
7026                 "criticality"
7027                 },
7028         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, value),
7029                 -1 /* Ambiguous tag (ANY?) */,
7030                 0,
7031                 &asn_DEF_value_92,
7032                 select_RICserviceUpdate_IEs_value_type,
7033                 { &asn_OER_memb_value_constr_92, &asn_PER_memb_value_constr_92,  memb_value_constraint_89 },
7034                 0, 0, /* No default value */
7035                 "value"
7036                 },
7037 };
7038 static const ber_tlv_tag_t asn_DEF_RICserviceUpdate_IEs_tags_89[] = {
7039         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7040 };
7041 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdate_IEs_tag2el_89[] = {
7042     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7043     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7044 };
7045 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdate_IEs_specs_89 = {
7046         sizeof(struct RICserviceUpdate_IEs),
7047         offsetof(struct RICserviceUpdate_IEs, _asn_ctx),
7048         asn_MAP_RICserviceUpdate_IEs_tag2el_89,
7049         2,      /* Count of tags in the map */
7050         0, 0, 0,        /* Optional elements (not needed) */
7051         -1,     /* First extension addition */
7052 };
7053 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdate_IEs = {
7054         "RICserviceUpdate-IEs",
7055         "RICserviceUpdate-IEs",
7056         &asn_OP_SEQUENCE,
7057         asn_DEF_RICserviceUpdate_IEs_tags_89,
7058         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89)
7059                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89[0]), /* 1 */
7060         asn_DEF_RICserviceUpdate_IEs_tags_89,   /* Same as above */
7061         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89)
7062                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89[0]), /* 1 */
7063         { 0, 0, SEQUENCE_constraint },
7064         asn_MBR_RICserviceUpdate_IEs_89,
7065         3,      /* Elements count */
7066         &asn_SPC_RICserviceUpdate_IEs_specs_89  /* Additional specs */
7067 };
7068
7069 static asn_TYPE_member_t asn_MBR_value_96[] = {
7070         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsID_List),
7071                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7072                 0,
7073                 &asn_DEF_RANfunctionsID_List,
7074                 0,
7075                 { 0, 0, 0 },
7076                 0, 0, /* No default value */
7077                 "RANfunctionsID-List"
7078                 },
7079         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsIDcause_List),
7080                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7081                 0,
7082                 &asn_DEF_RANfunctionsIDcause_List,
7083                 0,
7084                 { 0, 0, 0 },
7085                 0, 0, /* No default value */
7086                 "RANfunctionsIDcause-List"
7087                 },
7088 };
7089 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_96[] = {
7090     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsID-List */
7091     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsIDcause-List */
7092 };
7093 static asn_CHOICE_specifics_t asn_SPC_value_specs_96 = {
7094         sizeof(struct RICserviceUpdateAcknowledge_IEs__value),
7095         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, _asn_ctx),
7096         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, present),
7097         sizeof(((struct RICserviceUpdateAcknowledge_IEs__value *)0)->present),
7098         asn_MAP_value_tag2el_96,
7099         2,      /* Count of tags in the map */
7100         0, 0,
7101         -1      /* Extensions start */
7102 };
7103 static /* Use -fall-defs-global to expose */
7104 asn_TYPE_descriptor_t asn_DEF_value_96 = {
7105         "value",
7106         "value",
7107         &asn_OP_OPEN_TYPE,
7108         0,      /* No effective tags (pointer) */
7109         0,      /* No effective tags (count) */
7110         0,      /* No tags (pointer) */
7111         0,      /* No tags (count) */
7112         { 0, 0, OPEN_TYPE_constraint },
7113         asn_MBR_value_96,
7114         2,      /* Elements count */
7115         &asn_SPC_value_specs_96 /* Additional specs */
7116 };
7117
7118 asn_TYPE_member_t asn_MBR_RICserviceUpdateAcknowledge_IEs_93[] = {
7119         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, id),
7120                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7121                 0,
7122                 &asn_DEF_ProtocolIE_ID,
7123                 0,
7124                 { &asn_OER_memb_id_constr_94, &asn_PER_memb_id_constr_94,  memb_id_constraint_93 },
7125                 0, 0, /* No default value */
7126                 "id"
7127                 },
7128         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, criticality),
7129                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7130                 0,
7131                 &asn_DEF_Criticality,
7132                 select_RICserviceUpdateAcknowledge_IEs_criticality_type,
7133                 { &asn_OER_memb_criticality_constr_95, &asn_PER_memb_criticality_constr_95,  memb_criticality_constraint_93 },
7134                 0, 0, /* No default value */
7135                 "criticality"
7136                 },
7137         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, value),
7138                 -1 /* Ambiguous tag (ANY?) */,
7139                 0,
7140                 &asn_DEF_value_96,
7141                 select_RICserviceUpdateAcknowledge_IEs_value_type,
7142                 { &asn_OER_memb_value_constr_96, &asn_PER_memb_value_constr_96,  memb_value_constraint_93 },
7143                 0, 0, /* No default value */
7144                 "value"
7145                 },
7146 };
7147 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[] = {
7148         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7149 };
7150 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_93[] = {
7151     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7152     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7153 };
7154 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_93 = {
7155         sizeof(struct RICserviceUpdateAcknowledge_IEs),
7156         offsetof(struct RICserviceUpdateAcknowledge_IEs, _asn_ctx),
7157         asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_93,
7158         2,      /* Count of tags in the map */
7159         0, 0, 0,        /* Optional elements (not needed) */
7160         -1,     /* First extension addition */
7161 };
7162 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateAcknowledge_IEs = {
7163         "RICserviceUpdateAcknowledge-IEs",
7164         "RICserviceUpdateAcknowledge-IEs",
7165         &asn_OP_SEQUENCE,
7166         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93,
7167         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93)
7168                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[0]), /* 1 */
7169         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93,        /* Same as above */
7170         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93)
7171                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[0]), /* 1 */
7172         { 0, 0, SEQUENCE_constraint },
7173         asn_MBR_RICserviceUpdateAcknowledge_IEs_93,
7174         3,      /* Elements count */
7175         &asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_93       /* Additional specs */
7176 };
7177
7178 static asn_TYPE_member_t asn_MBR_value_100[] = {
7179         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.RANfunctionsIDcause_List),
7180                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7181                 0,
7182                 &asn_DEF_RANfunctionsIDcause_List,
7183                 0,
7184                 { 0, 0, 0 },
7185                 0, 0, /* No default value */
7186                 "RANfunctionsIDcause-List"
7187                 },
7188         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.TimeToWait),
7189                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7190                 0,
7191                 &asn_DEF_TimeToWait,
7192                 0,
7193                 { 0, 0, 0 },
7194                 0, 0, /* No default value */
7195                 "TimeToWait"
7196                 },
7197         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
7198                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7199                 0,
7200                 &asn_DEF_CriticalityDiagnostics,
7201                 0,
7202                 { 0, 0, 0 },
7203                 0, 0, /* No default value */
7204                 "CriticalityDiagnostics"
7205                 },
7206 };
7207 static const unsigned asn_MAP_value_to_canonical_100[] = { 1, 0, 2 };
7208 static const unsigned asn_MAP_value_from_canonical_100[] = { 1, 0, 2 };
7209 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_100[] = {
7210     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
7211     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsIDcause-List */
7212     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* CriticalityDiagnostics */
7213 };
7214 static asn_CHOICE_specifics_t asn_SPC_value_specs_100 = {
7215         sizeof(struct RICserviceUpdateFailure_IEs__value),
7216         offsetof(struct RICserviceUpdateFailure_IEs__value, _asn_ctx),
7217         offsetof(struct RICserviceUpdateFailure_IEs__value, present),
7218         sizeof(((struct RICserviceUpdateFailure_IEs__value *)0)->present),
7219         asn_MAP_value_tag2el_100,
7220         3,      /* Count of tags in the map */
7221         asn_MAP_value_to_canonical_100,
7222         asn_MAP_value_from_canonical_100,
7223         -1      /* Extensions start */
7224 };
7225 static /* Use -fall-defs-global to expose */
7226 asn_TYPE_descriptor_t asn_DEF_value_100 = {
7227         "value",
7228         "value",
7229         &asn_OP_OPEN_TYPE,
7230         0,      /* No effective tags (pointer) */
7231         0,      /* No effective tags (count) */
7232         0,      /* No tags (pointer) */
7233         0,      /* No tags (count) */
7234         { 0, 0, OPEN_TYPE_constraint },
7235         asn_MBR_value_100,
7236         3,      /* Elements count */
7237         &asn_SPC_value_specs_100        /* Additional specs */
7238 };
7239
7240 asn_TYPE_member_t asn_MBR_RICserviceUpdateFailure_IEs_97[] = {
7241         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, id),
7242                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7243                 0,
7244                 &asn_DEF_ProtocolIE_ID,
7245                 0,
7246                 { &asn_OER_memb_id_constr_98, &asn_PER_memb_id_constr_98,  memb_id_constraint_97 },
7247                 0, 0, /* No default value */
7248                 "id"
7249                 },
7250         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, criticality),
7251                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7252                 0,
7253                 &asn_DEF_Criticality,
7254                 select_RICserviceUpdateFailure_IEs_criticality_type,
7255                 { &asn_OER_memb_criticality_constr_99, &asn_PER_memb_criticality_constr_99,  memb_criticality_constraint_97 },
7256                 0, 0, /* No default value */
7257                 "criticality"
7258                 },
7259         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, value),
7260                 -1 /* Ambiguous tag (ANY?) */,
7261                 0,
7262                 &asn_DEF_value_100,
7263                 select_RICserviceUpdateFailure_IEs_value_type,
7264                 { &asn_OER_memb_value_constr_100, &asn_PER_memb_value_constr_100,  memb_value_constraint_97 },
7265                 0, 0, /* No default value */
7266                 "value"
7267                 },
7268 };
7269 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateFailure_IEs_tags_97[] = {
7270         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7271 };
7272 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateFailure_IEs_tag2el_97[] = {
7273     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7274     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7275 };
7276 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateFailure_IEs_specs_97 = {
7277         sizeof(struct RICserviceUpdateFailure_IEs),
7278         offsetof(struct RICserviceUpdateFailure_IEs, _asn_ctx),
7279         asn_MAP_RICserviceUpdateFailure_IEs_tag2el_97,
7280         2,      /* Count of tags in the map */
7281         0, 0, 0,        /* Optional elements (not needed) */
7282         -1,     /* First extension addition */
7283 };
7284 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateFailure_IEs = {
7285         "RICserviceUpdateFailure-IEs",
7286         "RICserviceUpdateFailure-IEs",
7287         &asn_OP_SEQUENCE,
7288         asn_DEF_RICserviceUpdateFailure_IEs_tags_97,
7289         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97)
7290                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97[0]), /* 1 */
7291         asn_DEF_RICserviceUpdateFailure_IEs_tags_97,    /* Same as above */
7292         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97)
7293                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97[0]), /* 1 */
7294         { 0, 0, SEQUENCE_constraint },
7295         asn_MBR_RICserviceUpdateFailure_IEs_97,
7296         3,      /* Elements count */
7297         &asn_SPC_RICserviceUpdateFailure_IEs_specs_97   /* Additional specs */
7298 };
7299
7300 static asn_TYPE_member_t asn_MBR_value_104[] = {
7301         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs__value, choice.RANfunctionsID_List),
7302                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7303                 0,
7304                 &asn_DEF_RANfunctionsID_List,
7305                 0,
7306                 { 0, 0, 0 },
7307                 0, 0, /* No default value */
7308                 "RANfunctionsID-List"
7309                 },
7310 };
7311 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_104[] = {
7312     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionsID-List */
7313 };
7314 static asn_CHOICE_specifics_t asn_SPC_value_specs_104 = {
7315         sizeof(struct RICserviceQuery_IEs__value),
7316         offsetof(struct RICserviceQuery_IEs__value, _asn_ctx),
7317         offsetof(struct RICserviceQuery_IEs__value, present),
7318         sizeof(((struct RICserviceQuery_IEs__value *)0)->present),
7319         asn_MAP_value_tag2el_104,
7320         1,      /* Count of tags in the map */
7321         0, 0,
7322         -1      /* Extensions start */
7323 };
7324 static /* Use -fall-defs-global to expose */
7325 asn_TYPE_descriptor_t asn_DEF_value_104 = {
7326         "value",
7327         "value",
7328         &asn_OP_OPEN_TYPE,
7329         0,      /* No effective tags (pointer) */
7330         0,      /* No effective tags (count) */
7331         0,      /* No tags (pointer) */
7332         0,      /* No tags (count) */
7333         { 0, 0, OPEN_TYPE_constraint },
7334         asn_MBR_value_104,
7335         1,      /* Elements count */
7336         &asn_SPC_value_specs_104        /* Additional specs */
7337 };
7338
7339 asn_TYPE_member_t asn_MBR_RICserviceQuery_IEs_101[] = {
7340         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, id),
7341                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
7342                 0,
7343                 &asn_DEF_ProtocolIE_ID,
7344                 0,
7345                 { &asn_OER_memb_id_constr_102, &asn_PER_memb_id_constr_102,  memb_id_constraint_101 },
7346                 0, 0, /* No default value */
7347                 "id"
7348                 },
7349         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, criticality),
7350                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7351                 0,
7352                 &asn_DEF_Criticality,
7353                 select_RICserviceQuery_IEs_criticality_type,
7354                 { &asn_OER_memb_criticality_constr_103, &asn_PER_memb_criticality_constr_103,  memb_criticality_constraint_101 },
7355                 0, 0, /* No default value */
7356                 "criticality"
7357                 },
7358         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, value),
7359                 -1 /* Ambiguous tag (ANY?) */,
7360                 0,
7361                 &asn_DEF_value_104,
7362                 select_RICserviceQuery_IEs_value_type,
7363                 { &asn_OER_memb_value_constr_104, &asn_PER_memb_value_constr_104,  memb_value_constraint_101 },
7364                 0, 0, /* No default value */
7365                 "value"
7366                 },
7367 };
7368 static const ber_tlv_tag_t asn_DEF_RICserviceQuery_IEs_tags_101[] = {
7369         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7370 };
7371 static const asn_TYPE_tag2member_t asn_MAP_RICserviceQuery_IEs_tag2el_101[] = {
7372     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* id */
7373     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 } /* criticality */
7374 };
7375 asn_SEQUENCE_specifics_t asn_SPC_RICserviceQuery_IEs_specs_101 = {
7376         sizeof(struct RICserviceQuery_IEs),
7377         offsetof(struct RICserviceQuery_IEs, _asn_ctx),
7378         asn_MAP_RICserviceQuery_IEs_tag2el_101,
7379         2,      /* Count of tags in the map */
7380         0, 0, 0,        /* Optional elements (not needed) */
7381         -1,     /* First extension addition */
7382 };
7383 asn_TYPE_descriptor_t asn_DEF_RICserviceQuery_IEs = {
7384         "RICserviceQuery-IEs",
7385         "RICserviceQuery-IEs",
7386         &asn_OP_SEQUENCE,
7387         asn_DEF_RICserviceQuery_IEs_tags_101,
7388         sizeof(asn_DEF_RICserviceQuery_IEs_tags_101)
7389                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_101[0]), /* 1 */
7390         asn_DEF_RICserviceQuery_IEs_tags_101,   /* Same as above */
7391         sizeof(asn_DEF_RICserviceQuery_IEs_tags_101)
7392                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_101[0]), /* 1 */
7393         { 0, 0, SEQUENCE_constraint },
7394         asn_MBR_RICserviceQuery_IEs_101,
7395         3,      /* Elements count */
7396         &asn_SPC_RICserviceQuery_IEs_specs_101  /* Additional specs */
7397 };
7398