e2sim/e2apv1sim/ricsim/ASN1c/ProtocolIE-Field.c

   1 /*
   2  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
   3  * From ASN.1 module "E2AP-Containers"
   4  *      found in "/home/rshacham/e2ap-v01.00.00.asn"
   5  *      `asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D .`
   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_per_constraints_t asn_PER_memb_id_constr_2 CC_NOTUSED = {
3687         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3688         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3689         0, 0    /* No PER value map */
3690 };
3691 static asn_per_constraints_t asn_PER_memb_criticality_constr_3 CC_NOTUSED = {
3692         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3693         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3694         0, 0    /* No PER value map */
3695 };
3696 static asn_per_constraints_t asn_PER_memb_value_constr_4 CC_NOTUSED = {
3697         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3698         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3699         0, 0    /* No PER value map */
3700 };
3701 static asn_per_constraints_t asn_PER_memb_id_constr_6 CC_NOTUSED = {
3702         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3703         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3704         0, 0    /* No PER value map */
3705 };
3706 static asn_per_constraints_t asn_PER_memb_criticality_constr_7 CC_NOTUSED = {
3707         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3708         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3709         0, 0    /* No PER value map */
3710 };
3711 static asn_per_constraints_t asn_PER_memb_value_constr_8 CC_NOTUSED = {
3712         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3713         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3714         0, 0    /* No PER value map */
3715 };
3716 static asn_per_constraints_t asn_PER_memb_id_constr_10 CC_NOTUSED = {
3717         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3718         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3719         0, 0    /* No PER value map */
3720 };
3721 static asn_per_constraints_t asn_PER_memb_criticality_constr_11 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_per_constraints_t asn_PER_memb_value_constr_12 CC_NOTUSED = {
3727         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3728         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3729         0, 0    /* No PER value map */
3730 };
3731 static asn_per_constraints_t asn_PER_memb_id_constr_14 CC_NOTUSED = {
3732         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3733         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3734         0, 0    /* No PER value map */
3735 };
3736 static asn_per_constraints_t asn_PER_memb_criticality_constr_15 CC_NOTUSED = {
3737         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3738         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3739         0, 0    /* No PER value map */
3740 };
3741 static asn_per_constraints_t asn_PER_memb_value_constr_16 CC_NOTUSED = {
3742         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3743         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3744         0, 0    /* No PER value map */
3745 };
3746 static asn_per_constraints_t asn_PER_memb_id_constr_18 CC_NOTUSED = {
3747         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3748         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3749         0, 0    /* No PER value map */
3750 };
3751 static asn_per_constraints_t asn_PER_memb_criticality_constr_19 CC_NOTUSED = {
3752         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3753         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3754         0, 0    /* No PER value map */
3755 };
3756 static asn_per_constraints_t asn_PER_memb_value_constr_20 CC_NOTUSED = {
3757         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3758         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3759         0, 0    /* No PER value map */
3760 };
3761 static asn_per_constraints_t asn_PER_memb_id_constr_22 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_per_constraints_t asn_PER_memb_criticality_constr_23 CC_NOTUSED = {
3767         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3768         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3769         0, 0    /* No PER value map */
3770 };
3771 static asn_per_constraints_t asn_PER_memb_value_constr_24 CC_NOTUSED = {
3772         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3773         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3774         0, 0    /* No PER value map */
3775 };
3776 static asn_per_constraints_t asn_PER_memb_id_constr_26 CC_NOTUSED = {
3777         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3778         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3779         0, 0    /* No PER value map */
3780 };
3781 static asn_per_constraints_t asn_PER_memb_criticality_constr_27 CC_NOTUSED = {
3782         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3783         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3784         0, 0    /* No PER value map */
3785 };
3786 static asn_per_constraints_t asn_PER_memb_value_constr_28 CC_NOTUSED = {
3787         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3788         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3789         0, 0    /* No PER value map */
3790 };
3791 static asn_per_constraints_t asn_PER_memb_id_constr_30 CC_NOTUSED = {
3792         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3793         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3794         0, 0    /* No PER value map */
3795 };
3796 static asn_per_constraints_t asn_PER_memb_criticality_constr_31 CC_NOTUSED = {
3797         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3798         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3799         0, 0    /* No PER value map */
3800 };
3801 static asn_per_constraints_t asn_PER_memb_value_constr_32 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_per_constraints_t asn_PER_memb_id_constr_34 CC_NOTUSED = {
3807         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3808         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3809         0, 0    /* No PER value map */
3810 };
3811 static asn_per_constraints_t asn_PER_memb_criticality_constr_35 CC_NOTUSED = {
3812         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3813         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3814         0, 0    /* No PER value map */
3815 };
3816 static asn_per_constraints_t asn_PER_memb_value_constr_36 CC_NOTUSED = {
3817         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3818         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3819         0, 0    /* No PER value map */
3820 };
3821 static asn_per_constraints_t asn_PER_memb_id_constr_38 CC_NOTUSED = {
3822         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3823         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3824         0, 0    /* No PER value map */
3825 };
3826 static asn_per_constraints_t asn_PER_memb_criticality_constr_39 CC_NOTUSED = {
3827         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3828         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3829         0, 0    /* No PER value map */
3830 };
3831 static asn_per_constraints_t asn_PER_memb_value_constr_40 CC_NOTUSED = {
3832         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3833         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3834         0, 0    /* No PER value map */
3835 };
3836 static asn_per_constraints_t asn_PER_memb_id_constr_42 CC_NOTUSED = {
3837         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3838         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3839         0, 0    /* No PER value map */
3840 };
3841 static asn_per_constraints_t asn_PER_memb_criticality_constr_43 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_per_constraints_t asn_PER_memb_value_constr_44 CC_NOTUSED = {
3847         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3848         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3849         0, 0    /* No PER value map */
3850 };
3851 static asn_per_constraints_t asn_PER_memb_id_constr_46 CC_NOTUSED = {
3852         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3853         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3854         0, 0    /* No PER value map */
3855 };
3856 static asn_per_constraints_t asn_PER_memb_criticality_constr_47 CC_NOTUSED = {
3857         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3858         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3859         0, 0    /* No PER value map */
3860 };
3861 static asn_per_constraints_t asn_PER_memb_value_constr_48 CC_NOTUSED = {
3862         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3863         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3864         0, 0    /* No PER value map */
3865 };
3866 static asn_per_constraints_t asn_PER_memb_id_constr_50 CC_NOTUSED = {
3867         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3868         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3869         0, 0    /* No PER value map */
3870 };
3871 static asn_per_constraints_t asn_PER_memb_criticality_constr_51 CC_NOTUSED = {
3872         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3873         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3874         0, 0    /* No PER value map */
3875 };
3876 static asn_per_constraints_t asn_PER_memb_value_constr_52 CC_NOTUSED = {
3877         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3878         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3879         0, 0    /* No PER value map */
3880 };
3881 static asn_per_constraints_t asn_PER_memb_id_constr_54 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_per_constraints_t asn_PER_memb_criticality_constr_55 CC_NOTUSED = {
3887         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3888         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3889         0, 0    /* No PER value map */
3890 };
3891 static asn_per_constraints_t asn_PER_memb_value_constr_56 CC_NOTUSED = {
3892         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3893         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3894         0, 0    /* No PER value map */
3895 };
3896 static asn_per_constraints_t asn_PER_memb_id_constr_58 CC_NOTUSED = {
3897         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3898         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3899         0, 0    /* No PER value map */
3900 };
3901 static asn_per_constraints_t asn_PER_memb_criticality_constr_59 CC_NOTUSED = {
3902         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3903         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3904         0, 0    /* No PER value map */
3905 };
3906 static asn_per_constraints_t asn_PER_memb_value_constr_60 CC_NOTUSED = {
3907         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3908         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3909         0, 0    /* No PER value map */
3910 };
3911 static asn_per_constraints_t asn_PER_memb_id_constr_62 CC_NOTUSED = {
3912         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3913         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3914         0, 0    /* No PER value map */
3915 };
3916 static asn_per_constraints_t asn_PER_memb_criticality_constr_63 CC_NOTUSED = {
3917         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3918         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3919         0, 0    /* No PER value map */
3920 };
3921 static asn_per_constraints_t asn_PER_memb_value_constr_64 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_per_constraints_t asn_PER_memb_id_constr_66 CC_NOTUSED = {
3927         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3928         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3929         0, 0    /* No PER value map */
3930 };
3931 static asn_per_constraints_t asn_PER_memb_criticality_constr_67 CC_NOTUSED = {
3932         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3933         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3934         0, 0    /* No PER value map */
3935 };
3936 static asn_per_constraints_t asn_PER_memb_value_constr_68 CC_NOTUSED = {
3937         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3938         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3939         0, 0    /* No PER value map */
3940 };
3941 static asn_per_constraints_t asn_PER_memb_id_constr_70 CC_NOTUSED = {
3942         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3943         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3944         0, 0    /* No PER value map */
3945 };
3946 static asn_per_constraints_t asn_PER_memb_criticality_constr_71 CC_NOTUSED = {
3947         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3948         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3949         0, 0    /* No PER value map */
3950 };
3951 static asn_per_constraints_t asn_PER_memb_value_constr_72 CC_NOTUSED = {
3952         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3953         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3954         0, 0    /* No PER value map */
3955 };
3956 static asn_per_constraints_t asn_PER_memb_id_constr_74 CC_NOTUSED = {
3957         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3958         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3959         0, 0    /* No PER value map */
3960 };
3961 static asn_per_constraints_t asn_PER_memb_criticality_constr_75 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_per_constraints_t asn_PER_memb_value_constr_76 CC_NOTUSED = {
3967         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3968         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3969         0, 0    /* No PER value map */
3970 };
3971 static asn_per_constraints_t asn_PER_memb_id_constr_78 CC_NOTUSED = {
3972         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3973         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3974         0, 0    /* No PER value map */
3975 };
3976 static asn_per_constraints_t asn_PER_memb_criticality_constr_79 CC_NOTUSED = {
3977         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3978         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3979         0, 0    /* No PER value map */
3980 };
3981 static asn_per_constraints_t asn_PER_memb_value_constr_80 CC_NOTUSED = {
3982         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3983         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3984         0, 0    /* No PER value map */
3985 };
3986 static asn_per_constraints_t asn_PER_memb_id_constr_82 CC_NOTUSED = {
3987         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3988         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3989         0, 0    /* No PER value map */
3990 };
3991 static asn_per_constraints_t asn_PER_memb_criticality_constr_83 CC_NOTUSED = {
3992         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3993         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3994         0, 0    /* No PER value map */
3995 };
3996 static asn_per_constraints_t asn_PER_memb_value_constr_84 CC_NOTUSED = {
3997         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3998         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3999         0, 0    /* No PER value map */
4000 };
4001 static asn_per_constraints_t asn_PER_memb_id_constr_86 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_per_constraints_t asn_PER_memb_criticality_constr_87 CC_NOTUSED = {
4007         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4008         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4009         0, 0    /* No PER value map */
4010 };
4011 static asn_per_constraints_t asn_PER_memb_value_constr_88 CC_NOTUSED = {
4012         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4013         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4014         0, 0    /* No PER value map */
4015 };
4016 static asn_per_constraints_t asn_PER_memb_id_constr_90 CC_NOTUSED = {
4017         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4018         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4019         0, 0    /* No PER value map */
4020 };
4021 static asn_per_constraints_t asn_PER_memb_criticality_constr_91 CC_NOTUSED = {
4022         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4023         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4024         0, 0    /* No PER value map */
4025 };
4026 static asn_per_constraints_t asn_PER_memb_value_constr_92 CC_NOTUSED = {
4027         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4028         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4029         0, 0    /* No PER value map */
4030 };
4031 static asn_per_constraints_t asn_PER_memb_id_constr_94 CC_NOTUSED = {
4032         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4033         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4034         0, 0    /* No PER value map */
4035 };
4036 static asn_per_constraints_t asn_PER_memb_criticality_constr_95 CC_NOTUSED = {
4037         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4038         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4039         0, 0    /* No PER value map */
4040 };
4041 static asn_per_constraints_t asn_PER_memb_value_constr_96 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_per_constraints_t asn_PER_memb_id_constr_98 CC_NOTUSED = {
4047         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4048         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4049         0, 0    /* No PER value map */
4050 };
4051 static asn_per_constraints_t asn_PER_memb_criticality_constr_99 CC_NOTUSED = {
4052         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4053         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4054         0, 0    /* No PER value map */
4055 };
4056 static asn_per_constraints_t asn_PER_memb_value_constr_100 CC_NOTUSED = {
4057         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4058         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4059         0, 0    /* No PER value map */
4060 };
4061 static asn_per_constraints_t asn_PER_memb_id_constr_102 CC_NOTUSED = {
4062         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4063         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4064         0, 0    /* No PER value map */
4065 };
4066 static asn_per_constraints_t asn_PER_memb_criticality_constr_103 CC_NOTUSED = {
4067         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4068         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4069         0, 0    /* No PER value map */
4070 };
4071 static asn_per_constraints_t asn_PER_memb_value_constr_104 CC_NOTUSED = {
4072         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4073         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4074         0, 0    /* No PER value map */
4075 };
4076 static asn_TYPE_member_t asn_MBR_value_4[] = {
4077         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs__value, choice.RICaction_ToBeSetup_Item),
4078                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4079                 0,
4080                 &asn_DEF_RICaction_ToBeSetup_Item,
4081                 0,
4082                 { 0, 0, 0 },
4083                 0, 0, /* No default value */
4084                 "RICaction-ToBeSetup-Item"
4085                 },
4086 };
4087 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_4[] = {
4088     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-ToBeSetup-Item */
4089 };
4090 static asn_CHOICE_specifics_t asn_SPC_value_specs_4 = {
4091         sizeof(struct RICaction_ToBeSetup_ItemIEs__value),
4092         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, _asn_ctx),
4093         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, present),
4094         sizeof(((struct RICaction_ToBeSetup_ItemIEs__value *)0)->present),
4095         asn_MAP_value_tag2el_4,
4096         1,      /* Count of tags in the map */
4097         0, 0,
4098         -1      /* Extensions start */
4099 };
4100 static /* Use -fall-defs-global to expose */
4101 asn_TYPE_descriptor_t asn_DEF_value_4 = {
4102         "value",
4103         "value",
4104         &asn_OP_OPEN_TYPE,
4105         0,      /* No effective tags (pointer) */
4106         0,      /* No effective tags (count) */
4107         0,      /* No tags (pointer) */
4108         0,      /* No tags (count) */
4109         { 0, 0, OPEN_TYPE_constraint },
4110         asn_MBR_value_4,
4111         1,      /* Elements count */
4112         &asn_SPC_value_specs_4  /* Additional specs */
4113 };
4114
4115 asn_TYPE_member_t asn_MBR_RICaction_ToBeSetup_ItemIEs_1[] = {
4116         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, id),
4117                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4118                 -1,     /* IMPLICIT tag at current level */
4119                 &asn_DEF_ProtocolIE_ID,
4120                 0,
4121                 { 0, &asn_PER_memb_id_constr_2,  memb_id_constraint_1 },
4122                 0, 0, /* No default value */
4123                 "id"
4124                 },
4125         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, criticality),
4126                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4127                 -1,     /* IMPLICIT tag at current level */
4128                 &asn_DEF_Criticality,
4129                 select_RICaction_ToBeSetup_ItemIEs_criticality_type,
4130                 { 0, &asn_PER_memb_criticality_constr_3,  memb_criticality_constraint_1 },
4131                 0, 0, /* No default value */
4132                 "criticality"
4133                 },
4134         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, value),
4135                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4136                 +1,     /* EXPLICIT tag at current level */
4137                 &asn_DEF_value_4,
4138                 select_RICaction_ToBeSetup_ItemIEs_value_type,
4139                 { 0, &asn_PER_memb_value_constr_4,  memb_value_constraint_1 },
4140                 0, 0, /* No default value */
4141                 "value"
4142                 },
4143 };
4144 static const ber_tlv_tag_t asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[] = {
4145         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4146 };
4147 static const asn_TYPE_tag2member_t asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1[] = {
4148     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4149     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4150     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4151 };
4152 asn_SEQUENCE_specifics_t asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1 = {
4153         sizeof(struct RICaction_ToBeSetup_ItemIEs),
4154         offsetof(struct RICaction_ToBeSetup_ItemIEs, _asn_ctx),
4155         asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1,
4156         3,      /* Count of tags in the map */
4157         0, 0, 0,        /* Optional elements (not needed) */
4158         -1,     /* First extension addition */
4159 };
4160 asn_TYPE_descriptor_t asn_DEF_RICaction_ToBeSetup_ItemIEs = {
4161         "RICaction-ToBeSetup-ItemIEs",
4162         "RICaction-ToBeSetup-ItemIEs",
4163         &asn_OP_SEQUENCE,
4164         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,
4165         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
4166                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
4167         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,     /* Same as above */
4168         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
4169                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
4170         { 0, 0, SEQUENCE_constraint },
4171         asn_MBR_RICaction_ToBeSetup_ItemIEs_1,
4172         3,      /* Elements count */
4173         &asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1    /* Additional specs */
4174 };
4175
4176 static asn_TYPE_member_t asn_MBR_value_8[] = {
4177         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs__value, choice.RICaction_Admitted_Item),
4178                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4179                 0,
4180                 &asn_DEF_RICaction_Admitted_Item,
4181                 0,
4182                 { 0, 0, 0 },
4183                 0, 0, /* No default value */
4184                 "RICaction-Admitted-Item"
4185                 },
4186 };
4187 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_8[] = {
4188     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-Admitted-Item */
4189 };
4190 static asn_CHOICE_specifics_t asn_SPC_value_specs_8 = {
4191         sizeof(struct RICaction_Admitted_ItemIEs__value),
4192         offsetof(struct RICaction_Admitted_ItemIEs__value, _asn_ctx),
4193         offsetof(struct RICaction_Admitted_ItemIEs__value, present),
4194         sizeof(((struct RICaction_Admitted_ItemIEs__value *)0)->present),
4195         asn_MAP_value_tag2el_8,
4196         1,      /* Count of tags in the map */
4197         0, 0,
4198         -1      /* Extensions start */
4199 };
4200 static /* Use -fall-defs-global to expose */
4201 asn_TYPE_descriptor_t asn_DEF_value_8 = {
4202         "value",
4203         "value",
4204         &asn_OP_OPEN_TYPE,
4205         0,      /* No effective tags (pointer) */
4206         0,      /* No effective tags (count) */
4207         0,      /* No tags (pointer) */
4208         0,      /* No tags (count) */
4209         { 0, 0, OPEN_TYPE_constraint },
4210         asn_MBR_value_8,
4211         1,      /* Elements count */
4212         &asn_SPC_value_specs_8  /* Additional specs */
4213 };
4214
4215 asn_TYPE_member_t asn_MBR_RICaction_Admitted_ItemIEs_5[] = {
4216         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, id),
4217                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4218                 -1,     /* IMPLICIT tag at current level */
4219                 &asn_DEF_ProtocolIE_ID,
4220                 0,
4221                 { 0, &asn_PER_memb_id_constr_6,  memb_id_constraint_5 },
4222                 0, 0, /* No default value */
4223                 "id"
4224                 },
4225         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, criticality),
4226                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4227                 -1,     /* IMPLICIT tag at current level */
4228                 &asn_DEF_Criticality,
4229                 select_RICaction_Admitted_ItemIEs_criticality_type,
4230                 { 0, &asn_PER_memb_criticality_constr_7,  memb_criticality_constraint_5 },
4231                 0, 0, /* No default value */
4232                 "criticality"
4233                 },
4234         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, value),
4235                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4236                 +1,     /* EXPLICIT tag at current level */
4237                 &asn_DEF_value_8,
4238                 select_RICaction_Admitted_ItemIEs_value_type,
4239                 { 0, &asn_PER_memb_value_constr_8,  memb_value_constraint_5 },
4240                 0, 0, /* No default value */
4241                 "value"
4242                 },
4243 };
4244 static const ber_tlv_tag_t asn_DEF_RICaction_Admitted_ItemIEs_tags_5[] = {
4245         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4246 };
4247 static const asn_TYPE_tag2member_t asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5[] = {
4248     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4249     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4250     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4251 };
4252 asn_SEQUENCE_specifics_t asn_SPC_RICaction_Admitted_ItemIEs_specs_5 = {
4253         sizeof(struct RICaction_Admitted_ItemIEs),
4254         offsetof(struct RICaction_Admitted_ItemIEs, _asn_ctx),
4255         asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5,
4256         3,      /* Count of tags in the map */
4257         0, 0, 0,        /* Optional elements (not needed) */
4258         -1,     /* First extension addition */
4259 };
4260 asn_TYPE_descriptor_t asn_DEF_RICaction_Admitted_ItemIEs = {
4261         "RICaction-Admitted-ItemIEs",
4262         "RICaction-Admitted-ItemIEs",
4263         &asn_OP_SEQUENCE,
4264         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,
4265         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
4266                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
4267         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,      /* Same as above */
4268         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
4269                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
4270         { 0, 0, SEQUENCE_constraint },
4271         asn_MBR_RICaction_Admitted_ItemIEs_5,
4272         3,      /* Elements count */
4273         &asn_SPC_RICaction_Admitted_ItemIEs_specs_5     /* Additional specs */
4274 };
4275
4276 static asn_TYPE_member_t asn_MBR_value_12[] = {
4277         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs__value, choice.RICaction_NotAdmitted_Item),
4278                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4279                 0,
4280                 &asn_DEF_RICaction_NotAdmitted_Item,
4281                 0,
4282                 { 0, 0, 0 },
4283                 0, 0, /* No default value */
4284                 "RICaction-NotAdmitted-Item"
4285                 },
4286 };
4287 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_12[] = {
4288     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-NotAdmitted-Item */
4289 };
4290 static asn_CHOICE_specifics_t asn_SPC_value_specs_12 = {
4291         sizeof(struct RICaction_NotAdmitted_ItemIEs__value),
4292         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, _asn_ctx),
4293         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, present),
4294         sizeof(((struct RICaction_NotAdmitted_ItemIEs__value *)0)->present),
4295         asn_MAP_value_tag2el_12,
4296         1,      /* Count of tags in the map */
4297         0, 0,
4298         -1      /* Extensions start */
4299 };
4300 static /* Use -fall-defs-global to expose */
4301 asn_TYPE_descriptor_t asn_DEF_value_12 = {
4302         "value",
4303         "value",
4304         &asn_OP_OPEN_TYPE,
4305         0,      /* No effective tags (pointer) */
4306         0,      /* No effective tags (count) */
4307         0,      /* No tags (pointer) */
4308         0,      /* No tags (count) */
4309         { 0, 0, OPEN_TYPE_constraint },
4310         asn_MBR_value_12,
4311         1,      /* Elements count */
4312         &asn_SPC_value_specs_12 /* Additional specs */
4313 };
4314
4315 asn_TYPE_member_t asn_MBR_RICaction_NotAdmitted_ItemIEs_9[] = {
4316         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, id),
4317                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4318                 -1,     /* IMPLICIT tag at current level */
4319                 &asn_DEF_ProtocolIE_ID,
4320                 0,
4321                 { 0, &asn_PER_memb_id_constr_10,  memb_id_constraint_9 },
4322                 0, 0, /* No default value */
4323                 "id"
4324                 },
4325         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, criticality),
4326                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4327                 -1,     /* IMPLICIT tag at current level */
4328                 &asn_DEF_Criticality,
4329                 select_RICaction_NotAdmitted_ItemIEs_criticality_type,
4330                 { 0, &asn_PER_memb_criticality_constr_11,  memb_criticality_constraint_9 },
4331                 0, 0, /* No default value */
4332                 "criticality"
4333                 },
4334         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, value),
4335                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4336                 +1,     /* EXPLICIT tag at current level */
4337                 &asn_DEF_value_12,
4338                 select_RICaction_NotAdmitted_ItemIEs_value_type,
4339                 { 0, &asn_PER_memb_value_constr_12,  memb_value_constraint_9 },
4340                 0, 0, /* No default value */
4341                 "value"
4342                 },
4343 };
4344 static const ber_tlv_tag_t asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[] = {
4345         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4346 };
4347 static const asn_TYPE_tag2member_t asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9[] = {
4348     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4349     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4350     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4351 };
4352 asn_SEQUENCE_specifics_t asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9 = {
4353         sizeof(struct RICaction_NotAdmitted_ItemIEs),
4354         offsetof(struct RICaction_NotAdmitted_ItemIEs, _asn_ctx),
4355         asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9,
4356         3,      /* Count of tags in the map */
4357         0, 0, 0,        /* Optional elements (not needed) */
4358         -1,     /* First extension addition */
4359 };
4360 asn_TYPE_descriptor_t asn_DEF_RICaction_NotAdmitted_ItemIEs = {
4361         "RICaction-NotAdmitted-ItemIEs",
4362         "RICaction-NotAdmitted-ItemIEs",
4363         &asn_OP_SEQUENCE,
4364         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,
4365         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
4366                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
4367         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,   /* Same as above */
4368         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
4369                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
4370         { 0, 0, SEQUENCE_constraint },
4371         asn_MBR_RICaction_NotAdmitted_ItemIEs_9,
4372         3,      /* Elements count */
4373         &asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9  /* Additional specs */
4374 };
4375
4376 static asn_TYPE_member_t asn_MBR_value_16[] = {
4377         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs__value, choice.RANfunction_Item),
4378                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4379                 0,
4380                 &asn_DEF_RANfunction_Item,
4381                 0,
4382                 { 0, 0, 0 },
4383                 0, 0, /* No default value */
4384                 "RANfunction-Item"
4385                 },
4386 };
4387 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_16[] = {
4388     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunction-Item */
4389 };
4390 static asn_CHOICE_specifics_t asn_SPC_value_specs_16 = {
4391         sizeof(struct RANfunction_ItemIEs__value),
4392         offsetof(struct RANfunction_ItemIEs__value, _asn_ctx),
4393         offsetof(struct RANfunction_ItemIEs__value, present),
4394         sizeof(((struct RANfunction_ItemIEs__value *)0)->present),
4395         asn_MAP_value_tag2el_16,
4396         1,      /* Count of tags in the map */
4397         0, 0,
4398         -1      /* Extensions start */
4399 };
4400 static /* Use -fall-defs-global to expose */
4401 asn_TYPE_descriptor_t asn_DEF_value_16 = {
4402         "value",
4403         "value",
4404         &asn_OP_OPEN_TYPE,
4405         0,      /* No effective tags (pointer) */
4406         0,      /* No effective tags (count) */
4407         0,      /* No tags (pointer) */
4408         0,      /* No tags (count) */
4409         { 0, 0, OPEN_TYPE_constraint },
4410         asn_MBR_value_16,
4411         1,      /* Elements count */
4412         &asn_SPC_value_specs_16 /* Additional specs */
4413 };
4414
4415 asn_TYPE_member_t asn_MBR_RANfunction_ItemIEs_13[] = {
4416         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, id),
4417                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4418                 -1,     /* IMPLICIT tag at current level */
4419                 &asn_DEF_ProtocolIE_ID,
4420                 0,
4421                 { 0, &asn_PER_memb_id_constr_14,  memb_id_constraint_13 },
4422                 0, 0, /* No default value */
4423                 "id"
4424                 },
4425         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, criticality),
4426                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4427                 -1,     /* IMPLICIT tag at current level */
4428                 &asn_DEF_Criticality,
4429                 select_RANfunction_ItemIEs_criticality_type,
4430                 { 0, &asn_PER_memb_criticality_constr_15,  memb_criticality_constraint_13 },
4431                 0, 0, /* No default value */
4432                 "criticality"
4433                 },
4434         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, value),
4435                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4436                 +1,     /* EXPLICIT tag at current level */
4437                 &asn_DEF_value_16,
4438                 select_RANfunction_ItemIEs_value_type,
4439                 { 0, &asn_PER_memb_value_constr_16,  memb_value_constraint_13 },
4440                 0, 0, /* No default value */
4441                 "value"
4442                 },
4443 };
4444 static const ber_tlv_tag_t asn_DEF_RANfunction_ItemIEs_tags_13[] = {
4445         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4446 };
4447 static const asn_TYPE_tag2member_t asn_MAP_RANfunction_ItemIEs_tag2el_13[] = {
4448     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4449     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4450     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4451 };
4452 asn_SEQUENCE_specifics_t asn_SPC_RANfunction_ItemIEs_specs_13 = {
4453         sizeof(struct RANfunction_ItemIEs),
4454         offsetof(struct RANfunction_ItemIEs, _asn_ctx),
4455         asn_MAP_RANfunction_ItemIEs_tag2el_13,
4456         3,      /* Count of tags in the map */
4457         0, 0, 0,        /* Optional elements (not needed) */
4458         -1,     /* First extension addition */
4459 };
4460 asn_TYPE_descriptor_t asn_DEF_RANfunction_ItemIEs = {
4461         "RANfunction-ItemIEs",
4462         "RANfunction-ItemIEs",
4463         &asn_OP_SEQUENCE,
4464         asn_DEF_RANfunction_ItemIEs_tags_13,
4465         sizeof(asn_DEF_RANfunction_ItemIEs_tags_13)
4466                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_13[0]), /* 1 */
4467         asn_DEF_RANfunction_ItemIEs_tags_13,    /* Same as above */
4468         sizeof(asn_DEF_RANfunction_ItemIEs_tags_13)
4469                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_13[0]), /* 1 */
4470         { 0, 0, SEQUENCE_constraint },
4471         asn_MBR_RANfunction_ItemIEs_13,
4472         3,      /* Elements count */
4473         &asn_SPC_RANfunction_ItemIEs_specs_13   /* Additional specs */
4474 };
4475
4476 static asn_TYPE_member_t asn_MBR_value_20[] = {
4477         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs__value, choice.RANfunctionID_Item),
4478                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4479                 0,
4480                 &asn_DEF_RANfunctionID_Item,
4481                 0,
4482                 { 0, 0, 0 },
4483                 0, 0, /* No default value */
4484                 "RANfunctionID-Item"
4485                 },
4486 };
4487 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_20[] = {
4488     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionID-Item */
4489 };
4490 static asn_CHOICE_specifics_t asn_SPC_value_specs_20 = {
4491         sizeof(struct RANfunctionID_ItemIEs__value),
4492         offsetof(struct RANfunctionID_ItemIEs__value, _asn_ctx),
4493         offsetof(struct RANfunctionID_ItemIEs__value, present),
4494         sizeof(((struct RANfunctionID_ItemIEs__value *)0)->present),
4495         asn_MAP_value_tag2el_20,
4496         1,      /* Count of tags in the map */
4497         0, 0,
4498         -1      /* Extensions start */
4499 };
4500 static /* Use -fall-defs-global to expose */
4501 asn_TYPE_descriptor_t asn_DEF_value_20 = {
4502         "value",
4503         "value",
4504         &asn_OP_OPEN_TYPE,
4505         0,      /* No effective tags (pointer) */
4506         0,      /* No effective tags (count) */
4507         0,      /* No tags (pointer) */
4508         0,      /* No tags (count) */
4509         { 0, 0, OPEN_TYPE_constraint },
4510         asn_MBR_value_20,
4511         1,      /* Elements count */
4512         &asn_SPC_value_specs_20 /* Additional specs */
4513 };
4514
4515 asn_TYPE_member_t asn_MBR_RANfunctionID_ItemIEs_17[] = {
4516         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, id),
4517                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4518                 -1,     /* IMPLICIT tag at current level */
4519                 &asn_DEF_ProtocolIE_ID,
4520                 0,
4521                 { 0, &asn_PER_memb_id_constr_18,  memb_id_constraint_17 },
4522                 0, 0, /* No default value */
4523                 "id"
4524                 },
4525         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, criticality),
4526                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4527                 -1,     /* IMPLICIT tag at current level */
4528                 &asn_DEF_Criticality,
4529                 select_RANfunctionID_ItemIEs_criticality_type,
4530                 { 0, &asn_PER_memb_criticality_constr_19,  memb_criticality_constraint_17 },
4531                 0, 0, /* No default value */
4532                 "criticality"
4533                 },
4534         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, value),
4535                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4536                 +1,     /* EXPLICIT tag at current level */
4537                 &asn_DEF_value_20,
4538                 select_RANfunctionID_ItemIEs_value_type,
4539                 { 0, &asn_PER_memb_value_constr_20,  memb_value_constraint_17 },
4540                 0, 0, /* No default value */
4541                 "value"
4542                 },
4543 };
4544 static const ber_tlv_tag_t asn_DEF_RANfunctionID_ItemIEs_tags_17[] = {
4545         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4546 };
4547 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionID_ItemIEs_tag2el_17[] = {
4548     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4549     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4550     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4551 };
4552 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionID_ItemIEs_specs_17 = {
4553         sizeof(struct RANfunctionID_ItemIEs),
4554         offsetof(struct RANfunctionID_ItemIEs, _asn_ctx),
4555         asn_MAP_RANfunctionID_ItemIEs_tag2el_17,
4556         3,      /* Count of tags in the map */
4557         0, 0, 0,        /* Optional elements (not needed) */
4558         -1,     /* First extension addition */
4559 };
4560 asn_TYPE_descriptor_t asn_DEF_RANfunctionID_ItemIEs = {
4561         "RANfunctionID-ItemIEs",
4562         "RANfunctionID-ItemIEs",
4563         &asn_OP_SEQUENCE,
4564         asn_DEF_RANfunctionID_ItemIEs_tags_17,
4565         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17)
4566                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
4567         asn_DEF_RANfunctionID_ItemIEs_tags_17,  /* Same as above */
4568         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17)
4569                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
4570         { 0, 0, SEQUENCE_constraint },
4571         asn_MBR_RANfunctionID_ItemIEs_17,
4572         3,      /* Elements count */
4573         &asn_SPC_RANfunctionID_ItemIEs_specs_17 /* Additional specs */
4574 };
4575
4576 static asn_TYPE_member_t asn_MBR_value_24[] = {
4577         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs__value, choice.RANfunctionIDcause_Item),
4578                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4579                 0,
4580                 &asn_DEF_RANfunctionIDcause_Item,
4581                 0,
4582                 { 0, 0, 0 },
4583                 0, 0, /* No default value */
4584                 "RANfunctionIDcause-Item"
4585                 },
4586 };
4587 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_24[] = {
4588     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionIDcause-Item */
4589 };
4590 static asn_CHOICE_specifics_t asn_SPC_value_specs_24 = {
4591         sizeof(struct RANfunctionIDcause_ItemIEs__value),
4592         offsetof(struct RANfunctionIDcause_ItemIEs__value, _asn_ctx),
4593         offsetof(struct RANfunctionIDcause_ItemIEs__value, present),
4594         sizeof(((struct RANfunctionIDcause_ItemIEs__value *)0)->present),
4595         asn_MAP_value_tag2el_24,
4596         1,      /* Count of tags in the map */
4597         0, 0,
4598         -1      /* Extensions start */
4599 };
4600 static /* Use -fall-defs-global to expose */
4601 asn_TYPE_descriptor_t asn_DEF_value_24 = {
4602         "value",
4603         "value",
4604         &asn_OP_OPEN_TYPE,
4605         0,      /* No effective tags (pointer) */
4606         0,      /* No effective tags (count) */
4607         0,      /* No tags (pointer) */
4608         0,      /* No tags (count) */
4609         { 0, 0, OPEN_TYPE_constraint },
4610         asn_MBR_value_24,
4611         1,      /* Elements count */
4612         &asn_SPC_value_specs_24 /* Additional specs */
4613 };
4614
4615 asn_TYPE_member_t asn_MBR_RANfunctionIDcause_ItemIEs_21[] = {
4616         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, id),
4617                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4618                 -1,     /* IMPLICIT tag at current level */
4619                 &asn_DEF_ProtocolIE_ID,
4620                 0,
4621                 { 0, &asn_PER_memb_id_constr_22,  memb_id_constraint_21 },
4622                 0, 0, /* No default value */
4623                 "id"
4624                 },
4625         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, criticality),
4626                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4627                 -1,     /* IMPLICIT tag at current level */
4628                 &asn_DEF_Criticality,
4629                 select_RANfunctionIDcause_ItemIEs_criticality_type,
4630                 { 0, &asn_PER_memb_criticality_constr_23,  memb_criticality_constraint_21 },
4631                 0, 0, /* No default value */
4632                 "criticality"
4633                 },
4634         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, value),
4635                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4636                 +1,     /* EXPLICIT tag at current level */
4637                 &asn_DEF_value_24,
4638                 select_RANfunctionIDcause_ItemIEs_value_type,
4639                 { 0, &asn_PER_memb_value_constr_24,  memb_value_constraint_21 },
4640                 0, 0, /* No default value */
4641                 "value"
4642                 },
4643 };
4644 static const ber_tlv_tag_t asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[] = {
4645         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4646 };
4647 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_21[] = {
4648     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4649     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4650     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4651 };
4652 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionIDcause_ItemIEs_specs_21 = {
4653         sizeof(struct RANfunctionIDcause_ItemIEs),
4654         offsetof(struct RANfunctionIDcause_ItemIEs, _asn_ctx),
4655         asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_21,
4656         3,      /* Count of tags in the map */
4657         0, 0, 0,        /* Optional elements (not needed) */
4658         -1,     /* First extension addition */
4659 };
4660 asn_TYPE_descriptor_t asn_DEF_RANfunctionIDcause_ItemIEs = {
4661         "RANfunctionIDcause-ItemIEs",
4662         "RANfunctionIDcause-ItemIEs",
4663         &asn_OP_SEQUENCE,
4664         asn_DEF_RANfunctionIDcause_ItemIEs_tags_21,
4665         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21)
4666                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
4667         asn_DEF_RANfunctionIDcause_ItemIEs_tags_21,     /* Same as above */
4668         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21)
4669                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
4670         { 0, 0, SEQUENCE_constraint },
4671         asn_MBR_RANfunctionIDcause_ItemIEs_21,
4672         3,      /* Elements count */
4673         &asn_SPC_RANfunctionIDcause_ItemIEs_specs_21    /* Additional specs */
4674 };
4675
4676 static asn_TYPE_member_t asn_MBR_value_28[] = {
4677         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICrequestID),
4678                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4679                 0,
4680                 &asn_DEF_RICrequestID,
4681                 0,
4682                 { 0, 0, 0 },
4683                 0, 0, /* No default value */
4684                 "RICrequestID"
4685                 },
4686         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RANfunctionID),
4687                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4688                 0,
4689                 &asn_DEF_RANfunctionID,
4690                 0,
4691                 { 0, 0, 0 },
4692                 0, 0, /* No default value */
4693                 "RANfunctionID"
4694                 },
4695         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICsubscriptionDetails),
4696                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4697                 0,
4698                 &asn_DEF_RICsubscriptionDetails,
4699                 0,
4700                 { 0, 0, 0 },
4701                 0, 0, /* No default value */
4702                 "RICsubscriptionDetails"
4703                 },
4704 };
4705 static const unsigned asn_MAP_value_to_canonical_28[] = { 1, 0, 2 };
4706 static const unsigned asn_MAP_value_from_canonical_28[] = { 1, 0, 2 };
4707 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_28[] = {
4708     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4709     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
4710     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* RICsubscriptionDetails */
4711 };
4712 static asn_CHOICE_specifics_t asn_SPC_value_specs_28 = {
4713         sizeof(struct RICsubscriptionRequest_IEs__value),
4714         offsetof(struct RICsubscriptionRequest_IEs__value, _asn_ctx),
4715         offsetof(struct RICsubscriptionRequest_IEs__value, present),
4716         sizeof(((struct RICsubscriptionRequest_IEs__value *)0)->present),
4717         asn_MAP_value_tag2el_28,
4718         3,      /* Count of tags in the map */
4719         asn_MAP_value_to_canonical_28,
4720         asn_MAP_value_from_canonical_28,
4721         -1      /* Extensions start */
4722 };
4723 static /* Use -fall-defs-global to expose */
4724 asn_TYPE_descriptor_t asn_DEF_value_28 = {
4725         "value",
4726         "value",
4727         &asn_OP_OPEN_TYPE,
4728         0,      /* No effective tags (pointer) */
4729         0,      /* No effective tags (count) */
4730         0,      /* No tags (pointer) */
4731         0,      /* No tags (count) */
4732         { 0, 0, OPEN_TYPE_constraint },
4733         asn_MBR_value_28,
4734         3,      /* Elements count */
4735         &asn_SPC_value_specs_28 /* Additional specs */
4736 };
4737
4738 asn_TYPE_member_t asn_MBR_RICsubscriptionRequest_IEs_25[] = {
4739         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, id),
4740                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4741                 -1,     /* IMPLICIT tag at current level */
4742                 &asn_DEF_ProtocolIE_ID,
4743                 0,
4744                 { 0, &asn_PER_memb_id_constr_26,  memb_id_constraint_25 },
4745                 0, 0, /* No default value */
4746                 "id"
4747                 },
4748         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, criticality),
4749                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4750                 -1,     /* IMPLICIT tag at current level */
4751                 &asn_DEF_Criticality,
4752                 select_RICsubscriptionRequest_IEs_criticality_type,
4753                 { 0, &asn_PER_memb_criticality_constr_27,  memb_criticality_constraint_25 },
4754                 0, 0, /* No default value */
4755                 "criticality"
4756                 },
4757         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, value),
4758                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4759                 +1,     /* EXPLICIT tag at current level */
4760                 &asn_DEF_value_28,
4761                 select_RICsubscriptionRequest_IEs_value_type,
4762                 { 0, &asn_PER_memb_value_constr_28,  memb_value_constraint_25 },
4763                 0, 0, /* No default value */
4764                 "value"
4765                 },
4766 };
4767 static const ber_tlv_tag_t asn_DEF_RICsubscriptionRequest_IEs_tags_25[] = {
4768         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4769 };
4770 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionRequest_IEs_tag2el_25[] = {
4771     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4772     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4773     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4774 };
4775 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionRequest_IEs_specs_25 = {
4776         sizeof(struct RICsubscriptionRequest_IEs),
4777         offsetof(struct RICsubscriptionRequest_IEs, _asn_ctx),
4778         asn_MAP_RICsubscriptionRequest_IEs_tag2el_25,
4779         3,      /* Count of tags in the map */
4780         0, 0, 0,        /* Optional elements (not needed) */
4781         -1,     /* First extension addition */
4782 };
4783 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionRequest_IEs = {
4784         "RICsubscriptionRequest-IEs",
4785         "RICsubscriptionRequest-IEs",
4786         &asn_OP_SEQUENCE,
4787         asn_DEF_RICsubscriptionRequest_IEs_tags_25,
4788         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25)
4789                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
4790         asn_DEF_RICsubscriptionRequest_IEs_tags_25,     /* Same as above */
4791         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25)
4792                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
4793         { 0, 0, SEQUENCE_constraint },
4794         asn_MBR_RICsubscriptionRequest_IEs_25,
4795         3,      /* Elements count */
4796         &asn_SPC_RICsubscriptionRequest_IEs_specs_25    /* Additional specs */
4797 };
4798
4799 static asn_TYPE_member_t asn_MBR_value_32[] = {
4800         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICrequestID),
4801                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4802                 0,
4803                 &asn_DEF_RICrequestID,
4804                 0,
4805                 { 0, 0, 0 },
4806                 0, 0, /* No default value */
4807                 "RICrequestID"
4808                 },
4809         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RANfunctionID),
4810                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4811                 0,
4812                 &asn_DEF_RANfunctionID,
4813                 0,
4814                 { 0, 0, 0 },
4815                 0, 0, /* No default value */
4816                 "RANfunctionID"
4817                 },
4818         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_Admitted_List),
4819                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4820                 0,
4821                 &asn_DEF_RICaction_Admitted_List,
4822                 0,
4823                 { 0, 0, 0 },
4824                 0, 0, /* No default value */
4825                 "RICaction-Admitted-List"
4826                 },
4827         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_NotAdmitted_List),
4828                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4829                 0,
4830                 &asn_DEF_RICaction_NotAdmitted_List,
4831                 0,
4832                 { 0, 0, 0 },
4833                 0, 0, /* No default value */
4834                 "RICaction-NotAdmitted-List"
4835                 },
4836 };
4837 static const unsigned asn_MAP_value_to_canonical_32[] = { 1, 0, 2, 3 };
4838 static const unsigned asn_MAP_value_from_canonical_32[] = { 1, 0, 2, 3 };
4839 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_32[] = {
4840     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4841     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
4842     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-Admitted-List */
4843     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* RICaction-NotAdmitted-List */
4844 };
4845 static asn_CHOICE_specifics_t asn_SPC_value_specs_32 = {
4846         sizeof(struct RICsubscriptionResponse_IEs__value),
4847         offsetof(struct RICsubscriptionResponse_IEs__value, _asn_ctx),
4848         offsetof(struct RICsubscriptionResponse_IEs__value, present),
4849         sizeof(((struct RICsubscriptionResponse_IEs__value *)0)->present),
4850         asn_MAP_value_tag2el_32,
4851         4,      /* Count of tags in the map */
4852         asn_MAP_value_to_canonical_32,
4853         asn_MAP_value_from_canonical_32,
4854         -1      /* Extensions start */
4855 };
4856 static /* Use -fall-defs-global to expose */
4857 asn_TYPE_descriptor_t asn_DEF_value_32 = {
4858         "value",
4859         "value",
4860         &asn_OP_OPEN_TYPE,
4861         0,      /* No effective tags (pointer) */
4862         0,      /* No effective tags (count) */
4863         0,      /* No tags (pointer) */
4864         0,      /* No tags (count) */
4865         { 0, 0, OPEN_TYPE_constraint },
4866         asn_MBR_value_32,
4867         4,      /* Elements count */
4868         &asn_SPC_value_specs_32 /* Additional specs */
4869 };
4870
4871 asn_TYPE_member_t asn_MBR_RICsubscriptionResponse_IEs_29[] = {
4872         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, id),
4873                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4874                 -1,     /* IMPLICIT tag at current level */
4875                 &asn_DEF_ProtocolIE_ID,
4876                 0,
4877                 { 0, &asn_PER_memb_id_constr_30,  memb_id_constraint_29 },
4878                 0, 0, /* No default value */
4879                 "id"
4880                 },
4881         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, criticality),
4882                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4883                 -1,     /* IMPLICIT tag at current level */
4884                 &asn_DEF_Criticality,
4885                 select_RICsubscriptionResponse_IEs_criticality_type,
4886                 { 0, &asn_PER_memb_criticality_constr_31,  memb_criticality_constraint_29 },
4887                 0, 0, /* No default value */
4888                 "criticality"
4889                 },
4890         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, value),
4891                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4892                 +1,     /* EXPLICIT tag at current level */
4893                 &asn_DEF_value_32,
4894                 select_RICsubscriptionResponse_IEs_value_type,
4895                 { 0, &asn_PER_memb_value_constr_32,  memb_value_constraint_29 },
4896                 0, 0, /* No default value */
4897                 "value"
4898                 },
4899 };
4900 static const ber_tlv_tag_t asn_DEF_RICsubscriptionResponse_IEs_tags_29[] = {
4901         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4902 };
4903 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionResponse_IEs_tag2el_29[] = {
4904     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4905     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4906     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4907 };
4908 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionResponse_IEs_specs_29 = {
4909         sizeof(struct RICsubscriptionResponse_IEs),
4910         offsetof(struct RICsubscriptionResponse_IEs, _asn_ctx),
4911         asn_MAP_RICsubscriptionResponse_IEs_tag2el_29,
4912         3,      /* Count of tags in the map */
4913         0, 0, 0,        /* Optional elements (not needed) */
4914         -1,     /* First extension addition */
4915 };
4916 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionResponse_IEs = {
4917         "RICsubscriptionResponse-IEs",
4918         "RICsubscriptionResponse-IEs",
4919         &asn_OP_SEQUENCE,
4920         asn_DEF_RICsubscriptionResponse_IEs_tags_29,
4921         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29)
4922                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
4923         asn_DEF_RICsubscriptionResponse_IEs_tags_29,    /* Same as above */
4924         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29)
4925                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
4926         { 0, 0, SEQUENCE_constraint },
4927         asn_MBR_RICsubscriptionResponse_IEs_29,
4928         3,      /* Elements count */
4929         &asn_SPC_RICsubscriptionResponse_IEs_specs_29   /* Additional specs */
4930 };
4931
4932 static asn_TYPE_member_t asn_MBR_value_36[] = {
4933         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICrequestID),
4934                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4935                 0,
4936                 &asn_DEF_RICrequestID,
4937                 0,
4938                 { 0, 0, 0 },
4939                 0, 0, /* No default value */
4940                 "RICrequestID"
4941                 },
4942         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RANfunctionID),
4943                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4944                 0,
4945                 &asn_DEF_RANfunctionID,
4946                 0,
4947                 { 0, 0, 0 },
4948                 0, 0, /* No default value */
4949                 "RANfunctionID"
4950                 },
4951         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICaction_NotAdmitted_List),
4952                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4953                 0,
4954                 &asn_DEF_RICaction_NotAdmitted_List,
4955                 0,
4956                 { 0, 0, 0 },
4957                 0, 0, /* No default value */
4958                 "RICaction-NotAdmitted-List"
4959                 },
4960         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.CriticalityDiagnostics),
4961                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4962                 0,
4963                 &asn_DEF_CriticalityDiagnostics,
4964                 0,
4965                 { 0, 0, 0 },
4966                 0, 0, /* No default value */
4967                 "CriticalityDiagnostics"
4968                 },
4969 };
4970 static const unsigned asn_MAP_value_to_canonical_36[] = { 1, 0, 2, 3 };
4971 static const unsigned asn_MAP_value_from_canonical_36[] = { 1, 0, 2, 3 };
4972 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_36[] = {
4973     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4974     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
4975     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-NotAdmitted-List */
4976     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* CriticalityDiagnostics */
4977 };
4978 static asn_CHOICE_specifics_t asn_SPC_value_specs_36 = {
4979         sizeof(struct RICsubscriptionFailure_IEs__value),
4980         offsetof(struct RICsubscriptionFailure_IEs__value, _asn_ctx),
4981         offsetof(struct RICsubscriptionFailure_IEs__value, present),
4982         sizeof(((struct RICsubscriptionFailure_IEs__value *)0)->present),
4983         asn_MAP_value_tag2el_36,
4984         4,      /* Count of tags in the map */
4985         asn_MAP_value_to_canonical_36,
4986         asn_MAP_value_from_canonical_36,
4987         -1      /* Extensions start */
4988 };
4989 static /* Use -fall-defs-global to expose */
4990 asn_TYPE_descriptor_t asn_DEF_value_36 = {
4991         "value",
4992         "value",
4993         &asn_OP_OPEN_TYPE,
4994         0,      /* No effective tags (pointer) */
4995         0,      /* No effective tags (count) */
4996         0,      /* No tags (pointer) */
4997         0,      /* No tags (count) */
4998         { 0, 0, OPEN_TYPE_constraint },
4999         asn_MBR_value_36,
5000         4,      /* Elements count */
5001         &asn_SPC_value_specs_36 /* Additional specs */
5002 };
5003
5004 asn_TYPE_member_t asn_MBR_RICsubscriptionFailure_IEs_33[] = {
5005         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, id),
5006                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5007                 -1,     /* IMPLICIT tag at current level */
5008                 &asn_DEF_ProtocolIE_ID,
5009                 0,
5010                 { 0, &asn_PER_memb_id_constr_34,  memb_id_constraint_33 },
5011                 0, 0, /* No default value */
5012                 "id"
5013                 },
5014         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, criticality),
5015                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5016                 -1,     /* IMPLICIT tag at current level */
5017                 &asn_DEF_Criticality,
5018                 select_RICsubscriptionFailure_IEs_criticality_type,
5019                 { 0, &asn_PER_memb_criticality_constr_35,  memb_criticality_constraint_33 },
5020                 0, 0, /* No default value */
5021                 "criticality"
5022                 },
5023         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, value),
5024                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5025                 +1,     /* EXPLICIT tag at current level */
5026                 &asn_DEF_value_36,
5027                 select_RICsubscriptionFailure_IEs_value_type,
5028                 { 0, &asn_PER_memb_value_constr_36,  memb_value_constraint_33 },
5029                 0, 0, /* No default value */
5030                 "value"
5031                 },
5032 };
5033 static const ber_tlv_tag_t asn_DEF_RICsubscriptionFailure_IEs_tags_33[] = {
5034         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5035 };
5036 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionFailure_IEs_tag2el_33[] = {
5037     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5038     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5039     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5040 };
5041 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionFailure_IEs_specs_33 = {
5042         sizeof(struct RICsubscriptionFailure_IEs),
5043         offsetof(struct RICsubscriptionFailure_IEs, _asn_ctx),
5044         asn_MAP_RICsubscriptionFailure_IEs_tag2el_33,
5045         3,      /* Count of tags in the map */
5046         0, 0, 0,        /* Optional elements (not needed) */
5047         -1,     /* First extension addition */
5048 };
5049 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionFailure_IEs = {
5050         "RICsubscriptionFailure-IEs",
5051         "RICsubscriptionFailure-IEs",
5052         &asn_OP_SEQUENCE,
5053         asn_DEF_RICsubscriptionFailure_IEs_tags_33,
5054         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33)
5055                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
5056         asn_DEF_RICsubscriptionFailure_IEs_tags_33,     /* Same as above */
5057         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33)
5058                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
5059         { 0, 0, SEQUENCE_constraint },
5060         asn_MBR_RICsubscriptionFailure_IEs_33,
5061         3,      /* Elements count */
5062         &asn_SPC_RICsubscriptionFailure_IEs_specs_33    /* Additional specs */
5063 };
5064
5065 static asn_TYPE_member_t asn_MBR_value_40[] = {
5066         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RICrequestID),
5067                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5068                 0,
5069                 &asn_DEF_RICrequestID,
5070                 0,
5071                 { 0, 0, 0 },
5072                 0, 0, /* No default value */
5073                 "RICrequestID"
5074                 },
5075         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RANfunctionID),
5076                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5077                 0,
5078                 &asn_DEF_RANfunctionID,
5079                 0,
5080                 { 0, 0, 0 },
5081                 0, 0, /* No default value */
5082                 "RANfunctionID"
5083                 },
5084 };
5085 static const unsigned asn_MAP_value_to_canonical_40[] = { 1, 0 };
5086 static const unsigned asn_MAP_value_from_canonical_40[] = { 1, 0 };
5087 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_40[] = {
5088     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5089     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5090 };
5091 static asn_CHOICE_specifics_t asn_SPC_value_specs_40 = {
5092         sizeof(struct RICsubscriptionDeleteRequest_IEs__value),
5093         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, _asn_ctx),
5094         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, present),
5095         sizeof(((struct RICsubscriptionDeleteRequest_IEs__value *)0)->present),
5096         asn_MAP_value_tag2el_40,
5097         2,      /* Count of tags in the map */
5098         asn_MAP_value_to_canonical_40,
5099         asn_MAP_value_from_canonical_40,
5100         -1      /* Extensions start */
5101 };
5102 static /* Use -fall-defs-global to expose */
5103 asn_TYPE_descriptor_t asn_DEF_value_40 = {
5104         "value",
5105         "value",
5106         &asn_OP_OPEN_TYPE,
5107         0,      /* No effective tags (pointer) */
5108         0,      /* No effective tags (count) */
5109         0,      /* No tags (pointer) */
5110         0,      /* No tags (count) */
5111         { 0, 0, OPEN_TYPE_constraint },
5112         asn_MBR_value_40,
5113         2,      /* Elements count */
5114         &asn_SPC_value_specs_40 /* Additional specs */
5115 };
5116
5117 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteRequest_IEs_37[] = {
5118         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, id),
5119                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5120                 -1,     /* IMPLICIT tag at current level */
5121                 &asn_DEF_ProtocolIE_ID,
5122                 0,
5123                 { 0, &asn_PER_memb_id_constr_38,  memb_id_constraint_37 },
5124                 0, 0, /* No default value */
5125                 "id"
5126                 },
5127         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, criticality),
5128                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5129                 -1,     /* IMPLICIT tag at current level */
5130                 &asn_DEF_Criticality,
5131                 select_RICsubscriptionDeleteRequest_IEs_criticality_type,
5132                 { 0, &asn_PER_memb_criticality_constr_39,  memb_criticality_constraint_37 },
5133                 0, 0, /* No default value */
5134                 "criticality"
5135                 },
5136         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, value),
5137                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5138                 +1,     /* EXPLICIT tag at current level */
5139                 &asn_DEF_value_40,
5140                 select_RICsubscriptionDeleteRequest_IEs_value_type,
5141                 { 0, &asn_PER_memb_value_constr_40,  memb_value_constraint_37 },
5142                 0, 0, /* No default value */
5143                 "value"
5144                 },
5145 };
5146 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[] = {
5147         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5148 };
5149 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_37[] = {
5150     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5151     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5152     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5153 };
5154 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_37 = {
5155         sizeof(struct RICsubscriptionDeleteRequest_IEs),
5156         offsetof(struct RICsubscriptionDeleteRequest_IEs, _asn_ctx),
5157         asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_37,
5158         3,      /* Count of tags in the map */
5159         0, 0, 0,        /* Optional elements (not needed) */
5160         -1,     /* First extension addition */
5161 };
5162 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteRequest_IEs = {
5163         "RICsubscriptionDeleteRequest-IEs",
5164         "RICsubscriptionDeleteRequest-IEs",
5165         &asn_OP_SEQUENCE,
5166         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37,
5167         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37)
5168                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
5169         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37,       /* Same as above */
5170         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37)
5171                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
5172         { 0, 0, SEQUENCE_constraint },
5173         asn_MBR_RICsubscriptionDeleteRequest_IEs_37,
5174         3,      /* Elements count */
5175         &asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_37      /* Additional specs */
5176 };
5177
5178 static asn_TYPE_member_t asn_MBR_value_44[] = {
5179         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RICrequestID),
5180                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5181                 0,
5182                 &asn_DEF_RICrequestID,
5183                 0,
5184                 { 0, 0, 0 },
5185                 0, 0, /* No default value */
5186                 "RICrequestID"
5187                 },
5188         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RANfunctionID),
5189                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5190                 0,
5191                 &asn_DEF_RANfunctionID,
5192                 0,
5193                 { 0, 0, 0 },
5194                 0, 0, /* No default value */
5195                 "RANfunctionID"
5196                 },
5197 };
5198 static const unsigned asn_MAP_value_to_canonical_44[] = { 1, 0 };
5199 static const unsigned asn_MAP_value_from_canonical_44[] = { 1, 0 };
5200 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_44[] = {
5201     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5202     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5203 };
5204 static asn_CHOICE_specifics_t asn_SPC_value_specs_44 = {
5205         sizeof(struct RICsubscriptionDeleteResponse_IEs__value),
5206         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, _asn_ctx),
5207         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, present),
5208         sizeof(((struct RICsubscriptionDeleteResponse_IEs__value *)0)->present),
5209         asn_MAP_value_tag2el_44,
5210         2,      /* Count of tags in the map */
5211         asn_MAP_value_to_canonical_44,
5212         asn_MAP_value_from_canonical_44,
5213         -1      /* Extensions start */
5214 };
5215 static /* Use -fall-defs-global to expose */
5216 asn_TYPE_descriptor_t asn_DEF_value_44 = {
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_44,
5226         2,      /* Elements count */
5227         &asn_SPC_value_specs_44 /* Additional specs */
5228 };
5229
5230 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteResponse_IEs_41[] = {
5231         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, id),
5232                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5233                 -1,     /* IMPLICIT tag at current level */
5234                 &asn_DEF_ProtocolIE_ID,
5235                 0,
5236                 { 0, &asn_PER_memb_id_constr_42,  memb_id_constraint_41 },
5237                 0, 0, /* No default value */
5238                 "id"
5239                 },
5240         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, criticality),
5241                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5242                 -1,     /* IMPLICIT tag at current level */
5243                 &asn_DEF_Criticality,
5244                 select_RICsubscriptionDeleteResponse_IEs_criticality_type,
5245                 { 0, &asn_PER_memb_criticality_constr_43,  memb_criticality_constraint_41 },
5246                 0, 0, /* No default value */
5247                 "criticality"
5248                 },
5249         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, value),
5250                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5251                 +1,     /* EXPLICIT tag at current level */
5252                 &asn_DEF_value_44,
5253                 select_RICsubscriptionDeleteResponse_IEs_value_type,
5254                 { 0, &asn_PER_memb_value_constr_44,  memb_value_constraint_41 },
5255                 0, 0, /* No default value */
5256                 "value"
5257                 },
5258 };
5259 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[] = {
5260         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5261 };
5262 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_41[] = {
5263     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5264     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5265     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5266 };
5267 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_41 = {
5268         sizeof(struct RICsubscriptionDeleteResponse_IEs),
5269         offsetof(struct RICsubscriptionDeleteResponse_IEs, _asn_ctx),
5270         asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_41,
5271         3,      /* Count of tags in the map */
5272         0, 0, 0,        /* Optional elements (not needed) */
5273         -1,     /* First extension addition */
5274 };
5275 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteResponse_IEs = {
5276         "RICsubscriptionDeleteResponse-IEs",
5277         "RICsubscriptionDeleteResponse-IEs",
5278         &asn_OP_SEQUENCE,
5279         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41,
5280         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41)
5281                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
5282         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41,      /* Same as above */
5283         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41)
5284                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
5285         { 0, 0, SEQUENCE_constraint },
5286         asn_MBR_RICsubscriptionDeleteResponse_IEs_41,
5287         3,      /* Elements count */
5288         &asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_41     /* Additional specs */
5289 };
5290
5291 static asn_TYPE_member_t asn_MBR_value_48[] = {
5292         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RICrequestID),
5293                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5294                 0,
5295                 &asn_DEF_RICrequestID,
5296                 0,
5297                 { 0, 0, 0 },
5298                 0, 0, /* No default value */
5299                 "RICrequestID"
5300                 },
5301         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RANfunctionID),
5302                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5303                 0,
5304                 &asn_DEF_RANfunctionID,
5305                 0,
5306                 { 0, 0, 0 },
5307                 0, 0, /* No default value */
5308                 "RANfunctionID"
5309                 },
5310         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.Cause),
5311                 -1 /* Ambiguous tag (CHOICE?) */,
5312                 0,
5313                 &asn_DEF_Cause,
5314                 0,
5315                 { 0, 0, 0 },
5316                 0, 0, /* No default value */
5317                 "Cause"
5318                 },
5319         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.CriticalityDiagnostics),
5320                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5321                 0,
5322                 &asn_DEF_CriticalityDiagnostics,
5323                 0,
5324                 { 0, 0, 0 },
5325                 0, 0, /* No default value */
5326                 "CriticalityDiagnostics"
5327                 },
5328 };
5329 static const unsigned asn_MAP_value_to_canonical_48[] = { 1, 0, 3, 2 };
5330 static const unsigned asn_MAP_value_from_canonical_48[] = { 1, 0, 3, 2 };
5331 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_48[] = {
5332     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5333     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
5334     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
5335     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
5336     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
5337     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
5338     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
5339     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
5340 };
5341 static asn_CHOICE_specifics_t asn_SPC_value_specs_48 = {
5342         sizeof(struct RICsubscriptionDeleteFailure_IEs__value),
5343         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, _asn_ctx),
5344         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, present),
5345         sizeof(((struct RICsubscriptionDeleteFailure_IEs__value *)0)->present),
5346         asn_MAP_value_tag2el_48,
5347         8,      /* Count of tags in the map */
5348         asn_MAP_value_to_canonical_48,
5349         asn_MAP_value_from_canonical_48,
5350         -1      /* Extensions start */
5351 };
5352 static /* Use -fall-defs-global to expose */
5353 asn_TYPE_descriptor_t asn_DEF_value_48 = {
5354         "value",
5355         "value",
5356         &asn_OP_OPEN_TYPE,
5357         0,      /* No effective tags (pointer) */
5358         0,      /* No effective tags (count) */
5359         0,      /* No tags (pointer) */
5360         0,      /* No tags (count) */
5361         { 0, 0, OPEN_TYPE_constraint },
5362         asn_MBR_value_48,
5363         4,      /* Elements count */
5364         &asn_SPC_value_specs_48 /* Additional specs */
5365 };
5366
5367 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteFailure_IEs_45[] = {
5368         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, id),
5369                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5370                 -1,     /* IMPLICIT tag at current level */
5371                 &asn_DEF_ProtocolIE_ID,
5372                 0,
5373                 { 0, &asn_PER_memb_id_constr_46,  memb_id_constraint_45 },
5374                 0, 0, /* No default value */
5375                 "id"
5376                 },
5377         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, criticality),
5378                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5379                 -1,     /* IMPLICIT tag at current level */
5380                 &asn_DEF_Criticality,
5381                 select_RICsubscriptionDeleteFailure_IEs_criticality_type,
5382                 { 0, &asn_PER_memb_criticality_constr_47,  memb_criticality_constraint_45 },
5383                 0, 0, /* No default value */
5384                 "criticality"
5385                 },
5386         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, value),
5387                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5388                 +1,     /* EXPLICIT tag at current level */
5389                 &asn_DEF_value_48,
5390                 select_RICsubscriptionDeleteFailure_IEs_value_type,
5391                 { 0, &asn_PER_memb_value_constr_48,  memb_value_constraint_45 },
5392                 0, 0, /* No default value */
5393                 "value"
5394                 },
5395 };
5396 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[] = {
5397         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5398 };
5399 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_45[] = {
5400     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5401     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5402     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5403 };
5404 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_45 = {
5405         sizeof(struct RICsubscriptionDeleteFailure_IEs),
5406         offsetof(struct RICsubscriptionDeleteFailure_IEs, _asn_ctx),
5407         asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_45,
5408         3,      /* Count of tags in the map */
5409         0, 0, 0,        /* Optional elements (not needed) */
5410         -1,     /* First extension addition */
5411 };
5412 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteFailure_IEs = {
5413         "RICsubscriptionDeleteFailure-IEs",
5414         "RICsubscriptionDeleteFailure-IEs",
5415         &asn_OP_SEQUENCE,
5416         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45,
5417         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45)
5418                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
5419         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45,       /* Same as above */
5420         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45)
5421                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
5422         { 0, 0, SEQUENCE_constraint },
5423         asn_MBR_RICsubscriptionDeleteFailure_IEs_45,
5424         3,      /* Elements count */
5425         &asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_45      /* Additional specs */
5426 };
5427
5428 static asn_TYPE_member_t asn_MBR_value_52[] = {
5429         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICrequestID),
5430                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5431                 0,
5432                 &asn_DEF_RICrequestID,
5433                 0,
5434                 { 0, 0, 0 },
5435                 0, 0, /* No default value */
5436                 "RICrequestID"
5437                 },
5438         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RANfunctionID),
5439                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5440                 0,
5441                 &asn_DEF_RANfunctionID,
5442                 0,
5443                 { 0, 0, 0 },
5444                 0, 0, /* No default value */
5445                 "RANfunctionID"
5446                 },
5447         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICactionID),
5448                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5449                 0,
5450                 &asn_DEF_RICactionID,
5451                 0,
5452                 { 0, 0, 0 },
5453                 0, 0, /* No default value */
5454                 "RICactionID"
5455                 },
5456         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationSN),
5457                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5458                 0,
5459                 &asn_DEF_RICindicationSN,
5460                 0,
5461                 { 0, 0, 0 },
5462                 0, 0, /* No default value */
5463                 "RICindicationSN"
5464                 },
5465         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationType),
5466                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5467                 0,
5468                 &asn_DEF_RICindicationType,
5469                 0,
5470                 { 0, 0, 0 },
5471                 0, 0, /* No default value */
5472                 "RICindicationType"
5473                 },
5474         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationHeader),
5475                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5476                 0,
5477                 &asn_DEF_RICindicationHeader,
5478                 0,
5479                 { 0, 0, 0 },
5480                 0, 0, /* No default value */
5481                 "RICindicationHeader"
5482                 },
5483         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationMessage),
5484                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5485                 0,
5486                 &asn_DEF_RICindicationMessage,
5487                 0,
5488                 { 0, 0, 0 },
5489                 0, 0, /* No default value */
5490                 "RICindicationMessage"
5491                 },
5492         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICcallProcessID),
5493                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5494                 0,
5495                 &asn_DEF_RICcallProcessID,
5496                 0,
5497                 { 0, 0, 0 },
5498                 0, 0, /* No default value */
5499                 "RICcallProcessID"
5500                 },
5501 };
5502 static const unsigned asn_MAP_value_to_canonical_52[] = { 1, 2, 3, 5, 6, 7, 4, 0 };
5503 static const unsigned asn_MAP_value_from_canonical_52[] = { 7, 0, 1, 2, 6, 3, 4, 5 };
5504 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_52[] = {
5505     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 2 }, /* RANfunctionID */
5506     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* RICactionID */
5507     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 0 }, /* RICindicationSN */
5508     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 5, 0, 2 }, /* RICindicationHeader */
5509     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 6, -1, 1 }, /* RICindicationMessage */
5510     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 7, -2, 0 }, /* RICcallProcessID */
5511     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* RICindicationType */
5512     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5513 };
5514 static asn_CHOICE_specifics_t asn_SPC_value_specs_52 = {
5515         sizeof(struct RICindication_IEs__value),
5516         offsetof(struct RICindication_IEs__value, _asn_ctx),
5517         offsetof(struct RICindication_IEs__value, present),
5518         sizeof(((struct RICindication_IEs__value *)0)->present),
5519         asn_MAP_value_tag2el_52,
5520         8,      /* Count of tags in the map */
5521         asn_MAP_value_to_canonical_52,
5522         asn_MAP_value_from_canonical_52,
5523         -1      /* Extensions start */
5524 };
5525 static /* Use -fall-defs-global to expose */
5526 asn_TYPE_descriptor_t asn_DEF_value_52 = {
5527         "value",
5528         "value",
5529         &asn_OP_OPEN_TYPE,
5530         0,      /* No effective tags (pointer) */
5531         0,      /* No effective tags (count) */
5532         0,      /* No tags (pointer) */
5533         0,      /* No tags (count) */
5534         { 0, 0, OPEN_TYPE_constraint },
5535         asn_MBR_value_52,
5536         8,      /* Elements count */
5537         &asn_SPC_value_specs_52 /* Additional specs */
5538 };
5539
5540 asn_TYPE_member_t asn_MBR_RICindication_IEs_49[] = {
5541         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, id),
5542                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5543                 -1,     /* IMPLICIT tag at current level */
5544                 &asn_DEF_ProtocolIE_ID,
5545                 0,
5546                 { 0, &asn_PER_memb_id_constr_50,  memb_id_constraint_49 },
5547                 0, 0, /* No default value */
5548                 "id"
5549                 },
5550         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, criticality),
5551                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5552                 -1,     /* IMPLICIT tag at current level */
5553                 &asn_DEF_Criticality,
5554                 select_RICindication_IEs_criticality_type,
5555                 { 0, &asn_PER_memb_criticality_constr_51,  memb_criticality_constraint_49 },
5556                 0, 0, /* No default value */
5557                 "criticality"
5558                 },
5559         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, value),
5560                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5561                 +1,     /* EXPLICIT tag at current level */
5562                 &asn_DEF_value_52,
5563                 select_RICindication_IEs_value_type,
5564                 { 0, &asn_PER_memb_value_constr_52,  memb_value_constraint_49 },
5565                 0, 0, /* No default value */
5566                 "value"
5567                 },
5568 };
5569 static const ber_tlv_tag_t asn_DEF_RICindication_IEs_tags_49[] = {
5570         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5571 };
5572 static const asn_TYPE_tag2member_t asn_MAP_RICindication_IEs_tag2el_49[] = {
5573     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5574     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5575     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5576 };
5577 asn_SEQUENCE_specifics_t asn_SPC_RICindication_IEs_specs_49 = {
5578         sizeof(struct RICindication_IEs),
5579         offsetof(struct RICindication_IEs, _asn_ctx),
5580         asn_MAP_RICindication_IEs_tag2el_49,
5581         3,      /* Count of tags in the map */
5582         0, 0, 0,        /* Optional elements (not needed) */
5583         -1,     /* First extension addition */
5584 };
5585 asn_TYPE_descriptor_t asn_DEF_RICindication_IEs = {
5586         "RICindication-IEs",
5587         "RICindication-IEs",
5588         &asn_OP_SEQUENCE,
5589         asn_DEF_RICindication_IEs_tags_49,
5590         sizeof(asn_DEF_RICindication_IEs_tags_49)
5591                 /sizeof(asn_DEF_RICindication_IEs_tags_49[0]), /* 1 */
5592         asn_DEF_RICindication_IEs_tags_49,      /* Same as above */
5593         sizeof(asn_DEF_RICindication_IEs_tags_49)
5594                 /sizeof(asn_DEF_RICindication_IEs_tags_49[0]), /* 1 */
5595         { 0, 0, SEQUENCE_constraint },
5596         asn_MBR_RICindication_IEs_49,
5597         3,      /* Elements count */
5598         &asn_SPC_RICindication_IEs_specs_49     /* Additional specs */
5599 };
5600
5601 static asn_TYPE_member_t asn_MBR_value_56[] = {
5602         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICrequestID),
5603                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5604                 0,
5605                 &asn_DEF_RICrequestID,
5606                 0,
5607                 { 0, 0, 0 },
5608                 0, 0, /* No default value */
5609                 "RICrequestID"
5610                 },
5611         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RANfunctionID),
5612                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5613                 0,
5614                 &asn_DEF_RANfunctionID,
5615                 0,
5616                 { 0, 0, 0 },
5617                 0, 0, /* No default value */
5618                 "RANfunctionID"
5619                 },
5620         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcallProcessID),
5621                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5622                 0,
5623                 &asn_DEF_RICcallProcessID,
5624                 0,
5625                 { 0, 0, 0 },
5626                 0, 0, /* No default value */
5627                 "RICcallProcessID"
5628                 },
5629         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolHeader),
5630                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5631                 0,
5632                 &asn_DEF_RICcontrolHeader,
5633                 0,
5634                 { 0, 0, 0 },
5635                 0, 0, /* No default value */
5636                 "RICcontrolHeader"
5637                 },
5638         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolMessage),
5639                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5640                 0,
5641                 &asn_DEF_RICcontrolMessage,
5642                 0,
5643                 { 0, 0, 0 },
5644                 0, 0, /* No default value */
5645                 "RICcontrolMessage"
5646                 },
5647         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolAckRequest),
5648                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5649                 0,
5650                 &asn_DEF_RICcontrolAckRequest,
5651                 0,
5652                 { 0, 0, 0 },
5653                 0, 0, /* No default value */
5654                 "RICcontrolAckRequest"
5655                 },
5656 };
5657 static const unsigned asn_MAP_value_to_canonical_56[] = { 1, 2, 3, 4, 5, 0 };
5658 static const unsigned asn_MAP_value_from_canonical_56[] = { 5, 0, 1, 2, 3, 4 };
5659 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_56[] = {
5660     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5661     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 2 }, /* RICcallProcessID */
5662     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 1 }, /* RICcontrolHeader */
5663     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -2, 0 }, /* RICcontrolMessage */
5664     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 5, 0, 0 }, /* RICcontrolAckRequest */
5665     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5666 };
5667 static asn_CHOICE_specifics_t asn_SPC_value_specs_56 = {
5668         sizeof(struct RICcontrolRequest_IEs__value),
5669         offsetof(struct RICcontrolRequest_IEs__value, _asn_ctx),
5670         offsetof(struct RICcontrolRequest_IEs__value, present),
5671         sizeof(((struct RICcontrolRequest_IEs__value *)0)->present),
5672         asn_MAP_value_tag2el_56,
5673         6,      /* Count of tags in the map */
5674         asn_MAP_value_to_canonical_56,
5675         asn_MAP_value_from_canonical_56,
5676         -1      /* Extensions start */
5677 };
5678 static /* Use -fall-defs-global to expose */
5679 asn_TYPE_descriptor_t asn_DEF_value_56 = {
5680         "value",
5681         "value",
5682         &asn_OP_OPEN_TYPE,
5683         0,      /* No effective tags (pointer) */
5684         0,      /* No effective tags (count) */
5685         0,      /* No tags (pointer) */
5686         0,      /* No tags (count) */
5687         { 0, 0, OPEN_TYPE_constraint },
5688         asn_MBR_value_56,
5689         6,      /* Elements count */
5690         &asn_SPC_value_specs_56 /* Additional specs */
5691 };
5692
5693 asn_TYPE_member_t asn_MBR_RICcontrolRequest_IEs_53[] = {
5694         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, id),
5695                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5696                 -1,     /* IMPLICIT tag at current level */
5697                 &asn_DEF_ProtocolIE_ID,
5698                 0,
5699                 { 0, &asn_PER_memb_id_constr_54,  memb_id_constraint_53 },
5700                 0, 0, /* No default value */
5701                 "id"
5702                 },
5703         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, criticality),
5704                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5705                 -1,     /* IMPLICIT tag at current level */
5706                 &asn_DEF_Criticality,
5707                 select_RICcontrolRequest_IEs_criticality_type,
5708                 { 0, &asn_PER_memb_criticality_constr_55,  memb_criticality_constraint_53 },
5709                 0, 0, /* No default value */
5710                 "criticality"
5711                 },
5712         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, value),
5713                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5714                 +1,     /* EXPLICIT tag at current level */
5715                 &asn_DEF_value_56,
5716                 select_RICcontrolRequest_IEs_value_type,
5717                 { 0, &asn_PER_memb_value_constr_56,  memb_value_constraint_53 },
5718                 0, 0, /* No default value */
5719                 "value"
5720                 },
5721 };
5722 static const ber_tlv_tag_t asn_DEF_RICcontrolRequest_IEs_tags_53[] = {
5723         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5724 };
5725 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolRequest_IEs_tag2el_53[] = {
5726     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5727     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5728     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5729 };
5730 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolRequest_IEs_specs_53 = {
5731         sizeof(struct RICcontrolRequest_IEs),
5732         offsetof(struct RICcontrolRequest_IEs, _asn_ctx),
5733         asn_MAP_RICcontrolRequest_IEs_tag2el_53,
5734         3,      /* Count of tags in the map */
5735         0, 0, 0,        /* Optional elements (not needed) */
5736         -1,     /* First extension addition */
5737 };
5738 asn_TYPE_descriptor_t asn_DEF_RICcontrolRequest_IEs = {
5739         "RICcontrolRequest-IEs",
5740         "RICcontrolRequest-IEs",
5741         &asn_OP_SEQUENCE,
5742         asn_DEF_RICcontrolRequest_IEs_tags_53,
5743         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53)
5744                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
5745         asn_DEF_RICcontrolRequest_IEs_tags_53,  /* Same as above */
5746         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53)
5747                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
5748         { 0, 0, SEQUENCE_constraint },
5749         asn_MBR_RICcontrolRequest_IEs_53,
5750         3,      /* Elements count */
5751         &asn_SPC_RICcontrolRequest_IEs_specs_53 /* Additional specs */
5752 };
5753
5754 static asn_TYPE_member_t asn_MBR_value_60[] = {
5755         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICrequestID),
5756                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5757                 0,
5758                 &asn_DEF_RICrequestID,
5759                 0,
5760                 { 0, 0, 0 },
5761                 0, 0, /* No default value */
5762                 "RICrequestID"
5763                 },
5764         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RANfunctionID),
5765                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5766                 0,
5767                 &asn_DEF_RANfunctionID,
5768                 0,
5769                 { 0, 0, 0 },
5770                 0, 0, /* No default value */
5771                 "RANfunctionID"
5772                 },
5773         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcallProcessID),
5774                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5775                 0,
5776                 &asn_DEF_RICcallProcessID,
5777                 0,
5778                 { 0, 0, 0 },
5779                 0, 0, /* No default value */
5780                 "RICcallProcessID"
5781                 },
5782         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolStatus),
5783                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5784                 0,
5785                 &asn_DEF_RICcontrolStatus,
5786                 0,
5787                 { 0, 0, 0 },
5788                 0, 0, /* No default value */
5789                 "RICcontrolStatus"
5790                 },
5791         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolOutcome),
5792                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5793                 0,
5794                 &asn_DEF_RICcontrolOutcome,
5795                 0,
5796                 { 0, 0, 0 },
5797                 0, 0, /* No default value */
5798                 "RICcontrolOutcome"
5799                 },
5800 };
5801 static const unsigned asn_MAP_value_to_canonical_60[] = { 1, 2, 4, 3, 0 };
5802 static const unsigned asn_MAP_value_from_canonical_60[] = { 4, 0, 1, 3, 2 };
5803 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_60[] = {
5804     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5805     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
5806     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
5807     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 3, 0, 0 }, /* RICcontrolStatus */
5808     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5809 };
5810 static asn_CHOICE_specifics_t asn_SPC_value_specs_60 = {
5811         sizeof(struct RICcontrolAcknowledge_IEs__value),
5812         offsetof(struct RICcontrolAcknowledge_IEs__value, _asn_ctx),
5813         offsetof(struct RICcontrolAcknowledge_IEs__value, present),
5814         sizeof(((struct RICcontrolAcknowledge_IEs__value *)0)->present),
5815         asn_MAP_value_tag2el_60,
5816         5,      /* Count of tags in the map */
5817         asn_MAP_value_to_canonical_60,
5818         asn_MAP_value_from_canonical_60,
5819         -1      /* Extensions start */
5820 };
5821 static /* Use -fall-defs-global to expose */
5822 asn_TYPE_descriptor_t asn_DEF_value_60 = {
5823         "value",
5824         "value",
5825         &asn_OP_OPEN_TYPE,
5826         0,      /* No effective tags (pointer) */
5827         0,      /* No effective tags (count) */
5828         0,      /* No tags (pointer) */
5829         0,      /* No tags (count) */
5830         { 0, 0, OPEN_TYPE_constraint },
5831         asn_MBR_value_60,
5832         5,      /* Elements count */
5833         &asn_SPC_value_specs_60 /* Additional specs */
5834 };
5835
5836 asn_TYPE_member_t asn_MBR_RICcontrolAcknowledge_IEs_57[] = {
5837         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, id),
5838                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5839                 -1,     /* IMPLICIT tag at current level */
5840                 &asn_DEF_ProtocolIE_ID,
5841                 0,
5842                 { 0, &asn_PER_memb_id_constr_58,  memb_id_constraint_57 },
5843                 0, 0, /* No default value */
5844                 "id"
5845                 },
5846         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, criticality),
5847                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5848                 -1,     /* IMPLICIT tag at current level */
5849                 &asn_DEF_Criticality,
5850                 select_RICcontrolAcknowledge_IEs_criticality_type,
5851                 { 0, &asn_PER_memb_criticality_constr_59,  memb_criticality_constraint_57 },
5852                 0, 0, /* No default value */
5853                 "criticality"
5854                 },
5855         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, value),
5856                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5857                 +1,     /* EXPLICIT tag at current level */
5858                 &asn_DEF_value_60,
5859                 select_RICcontrolAcknowledge_IEs_value_type,
5860                 { 0, &asn_PER_memb_value_constr_60,  memb_value_constraint_57 },
5861                 0, 0, /* No default value */
5862                 "value"
5863                 },
5864 };
5865 static const ber_tlv_tag_t asn_DEF_RICcontrolAcknowledge_IEs_tags_57[] = {
5866         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5867 };
5868 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolAcknowledge_IEs_tag2el_57[] = {
5869     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5870     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5871     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5872 };
5873 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolAcknowledge_IEs_specs_57 = {
5874         sizeof(struct RICcontrolAcknowledge_IEs),
5875         offsetof(struct RICcontrolAcknowledge_IEs, _asn_ctx),
5876         asn_MAP_RICcontrolAcknowledge_IEs_tag2el_57,
5877         3,      /* Count of tags in the map */
5878         0, 0, 0,        /* Optional elements (not needed) */
5879         -1,     /* First extension addition */
5880 };
5881 asn_TYPE_descriptor_t asn_DEF_RICcontrolAcknowledge_IEs = {
5882         "RICcontrolAcknowledge-IEs",
5883         "RICcontrolAcknowledge-IEs",
5884         &asn_OP_SEQUENCE,
5885         asn_DEF_RICcontrolAcknowledge_IEs_tags_57,
5886         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57)
5887                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
5888         asn_DEF_RICcontrolAcknowledge_IEs_tags_57,      /* Same as above */
5889         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57)
5890                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
5891         { 0, 0, SEQUENCE_constraint },
5892         asn_MBR_RICcontrolAcknowledge_IEs_57,
5893         3,      /* Elements count */
5894         &asn_SPC_RICcontrolAcknowledge_IEs_specs_57     /* Additional specs */
5895 };
5896
5897 static asn_TYPE_member_t asn_MBR_value_64[] = {
5898         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICrequestID),
5899                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5900                 0,
5901                 &asn_DEF_RICrequestID,
5902                 0,
5903                 { 0, 0, 0 },
5904                 0, 0, /* No default value */
5905                 "RICrequestID"
5906                 },
5907         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RANfunctionID),
5908                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5909                 0,
5910                 &asn_DEF_RANfunctionID,
5911                 0,
5912                 { 0, 0, 0 },
5913                 0, 0, /* No default value */
5914                 "RANfunctionID"
5915                 },
5916         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcallProcessID),
5917                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5918                 0,
5919                 &asn_DEF_RICcallProcessID,
5920                 0,
5921                 { 0, 0, 0 },
5922                 0, 0, /* No default value */
5923                 "RICcallProcessID"
5924                 },
5925         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.Cause),
5926                 -1 /* Ambiguous tag (CHOICE?) */,
5927                 0,
5928                 &asn_DEF_Cause,
5929                 0,
5930                 { 0, 0, 0 },
5931                 0, 0, /* No default value */
5932                 "Cause"
5933                 },
5934         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcontrolOutcome),
5935                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5936                 0,
5937                 &asn_DEF_RICcontrolOutcome,
5938                 0,
5939                 { 0, 0, 0 },
5940                 0, 0, /* No default value */
5941                 "RICcontrolOutcome"
5942                 },
5943 };
5944 static const unsigned asn_MAP_value_to_canonical_64[] = { 1, 2, 4, 0, 3 };
5945 static const unsigned asn_MAP_value_from_canonical_64[] = { 3, 0, 1, 4, 2 };
5946 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_64[] = {
5947     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5948     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
5949     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
5950     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* RICrequestID */
5951     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 3, 0, 0 }, /* ricRequest */
5952     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* ricService */
5953     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 3, 0, 0 }, /* transport */
5954     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
5955     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* misc */
5956 };
5957 static asn_CHOICE_specifics_t asn_SPC_value_specs_64 = {
5958         sizeof(struct RICcontrolFailure_IEs__value),
5959         offsetof(struct RICcontrolFailure_IEs__value, _asn_ctx),
5960         offsetof(struct RICcontrolFailure_IEs__value, present),
5961         sizeof(((struct RICcontrolFailure_IEs__value *)0)->present),
5962         asn_MAP_value_tag2el_64,
5963         9,      /* Count of tags in the map */
5964         asn_MAP_value_to_canonical_64,
5965         asn_MAP_value_from_canonical_64,
5966         -1      /* Extensions start */
5967 };
5968 static /* Use -fall-defs-global to expose */
5969 asn_TYPE_descriptor_t asn_DEF_value_64 = {
5970         "value",
5971         "value",
5972         &asn_OP_OPEN_TYPE,
5973         0,      /* No effective tags (pointer) */
5974         0,      /* No effective tags (count) */
5975         0,      /* No tags (pointer) */
5976         0,      /* No tags (count) */
5977         { 0, 0, OPEN_TYPE_constraint },
5978         asn_MBR_value_64,
5979         5,      /* Elements count */
5980         &asn_SPC_value_specs_64 /* Additional specs */
5981 };
5982
5983 asn_TYPE_member_t asn_MBR_RICcontrolFailure_IEs_61[] = {
5984         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, id),
5985                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5986                 -1,     /* IMPLICIT tag at current level */
5987                 &asn_DEF_ProtocolIE_ID,
5988                 0,
5989                 { 0, &asn_PER_memb_id_constr_62,  memb_id_constraint_61 },
5990                 0, 0, /* No default value */
5991                 "id"
5992                 },
5993         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, criticality),
5994                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5995                 -1,     /* IMPLICIT tag at current level */
5996                 &asn_DEF_Criticality,
5997                 select_RICcontrolFailure_IEs_criticality_type,
5998                 { 0, &asn_PER_memb_criticality_constr_63,  memb_criticality_constraint_61 },
5999                 0, 0, /* No default value */
6000                 "criticality"
6001                 },
6002         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, value),
6003                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6004                 +1,     /* EXPLICIT tag at current level */
6005                 &asn_DEF_value_64,
6006                 select_RICcontrolFailure_IEs_value_type,
6007                 { 0, &asn_PER_memb_value_constr_64,  memb_value_constraint_61 },
6008                 0, 0, /* No default value */
6009                 "value"
6010                 },
6011 };
6012 static const ber_tlv_tag_t asn_DEF_RICcontrolFailure_IEs_tags_61[] = {
6013         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6014 };
6015 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolFailure_IEs_tag2el_61[] = {
6016     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6017     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6018     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6019 };
6020 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolFailure_IEs_specs_61 = {
6021         sizeof(struct RICcontrolFailure_IEs),
6022         offsetof(struct RICcontrolFailure_IEs, _asn_ctx),
6023         asn_MAP_RICcontrolFailure_IEs_tag2el_61,
6024         3,      /* Count of tags in the map */
6025         0, 0, 0,        /* Optional elements (not needed) */
6026         -1,     /* First extension addition */
6027 };
6028 asn_TYPE_descriptor_t asn_DEF_RICcontrolFailure_IEs = {
6029         "RICcontrolFailure-IEs",
6030         "RICcontrolFailure-IEs",
6031         &asn_OP_SEQUENCE,
6032         asn_DEF_RICcontrolFailure_IEs_tags_61,
6033         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61)
6034                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
6035         asn_DEF_RICcontrolFailure_IEs_tags_61,  /* Same as above */
6036         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61)
6037                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
6038         { 0, 0, SEQUENCE_constraint },
6039         asn_MBR_RICcontrolFailure_IEs_61,
6040         3,      /* Elements count */
6041         &asn_SPC_RICcontrolFailure_IEs_specs_61 /* Additional specs */
6042 };
6043
6044 static asn_TYPE_member_t asn_MBR_value_68[] = {
6045         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RICrequestID),
6046                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6047                 0,
6048                 &asn_DEF_RICrequestID,
6049                 0,
6050                 { 0, 0, 0 },
6051                 0, 0, /* No default value */
6052                 "RICrequestID"
6053                 },
6054         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RANfunctionID),
6055                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6056                 0,
6057                 &asn_DEF_RANfunctionID,
6058                 0,
6059                 { 0, 0, 0 },
6060                 0, 0, /* No default value */
6061                 "RANfunctionID"
6062                 },
6063         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.Cause),
6064                 -1 /* Ambiguous tag (CHOICE?) */,
6065                 0,
6066                 &asn_DEF_Cause,
6067                 0,
6068                 { 0, 0, 0 },
6069                 0, 0, /* No default value */
6070                 "Cause"
6071                 },
6072         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.CriticalityDiagnostics),
6073                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6074                 0,
6075                 &asn_DEF_CriticalityDiagnostics,
6076                 0,
6077                 { 0, 0, 0 },
6078                 0, 0, /* No default value */
6079                 "CriticalityDiagnostics"
6080                 },
6081 };
6082 static const unsigned asn_MAP_value_to_canonical_68[] = { 1, 0, 3, 2 };
6083 static const unsigned asn_MAP_value_from_canonical_68[] = { 1, 0, 3, 2 };
6084 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_68[] = {
6085     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6086     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
6087     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
6088     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
6089     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
6090     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
6091     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
6092     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
6093 };
6094 static asn_CHOICE_specifics_t asn_SPC_value_specs_68 = {
6095         sizeof(struct ErrorIndication_IEs__value),
6096         offsetof(struct ErrorIndication_IEs__value, _asn_ctx),
6097         offsetof(struct ErrorIndication_IEs__value, present),
6098         sizeof(((struct ErrorIndication_IEs__value *)0)->present),
6099         asn_MAP_value_tag2el_68,
6100         8,      /* Count of tags in the map */
6101         asn_MAP_value_to_canonical_68,
6102         asn_MAP_value_from_canonical_68,
6103         -1      /* Extensions start */
6104 };
6105 static /* Use -fall-defs-global to expose */
6106 asn_TYPE_descriptor_t asn_DEF_value_68 = {
6107         "value",
6108         "value",
6109         &asn_OP_OPEN_TYPE,
6110         0,      /* No effective tags (pointer) */
6111         0,      /* No effective tags (count) */
6112         0,      /* No tags (pointer) */
6113         0,      /* No tags (count) */
6114         { 0, 0, OPEN_TYPE_constraint },
6115         asn_MBR_value_68,
6116         4,      /* Elements count */
6117         &asn_SPC_value_specs_68 /* Additional specs */
6118 };
6119
6120 asn_TYPE_member_t asn_MBR_ErrorIndication_IEs_65[] = {
6121         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, id),
6122                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6123                 -1,     /* IMPLICIT tag at current level */
6124                 &asn_DEF_ProtocolIE_ID,
6125                 0,
6126                 { 0, &asn_PER_memb_id_constr_66,  memb_id_constraint_65 },
6127                 0, 0, /* No default value */
6128                 "id"
6129                 },
6130         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, criticality),
6131                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6132                 -1,     /* IMPLICIT tag at current level */
6133                 &asn_DEF_Criticality,
6134                 select_ErrorIndication_IEs_criticality_type,
6135                 { 0, &asn_PER_memb_criticality_constr_67,  memb_criticality_constraint_65 },
6136                 0, 0, /* No default value */
6137                 "criticality"
6138                 },
6139         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, value),
6140                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6141                 +1,     /* EXPLICIT tag at current level */
6142                 &asn_DEF_value_68,
6143                 select_ErrorIndication_IEs_value_type,
6144                 { 0, &asn_PER_memb_value_constr_68,  memb_value_constraint_65 },
6145                 0, 0, /* No default value */
6146                 "value"
6147                 },
6148 };
6149 static const ber_tlv_tag_t asn_DEF_ErrorIndication_IEs_tags_65[] = {
6150         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6151 };
6152 static const asn_TYPE_tag2member_t asn_MAP_ErrorIndication_IEs_tag2el_65[] = {
6153     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6154     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6155     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6156 };
6157 asn_SEQUENCE_specifics_t asn_SPC_ErrorIndication_IEs_specs_65 = {
6158         sizeof(struct ErrorIndication_IEs),
6159         offsetof(struct ErrorIndication_IEs, _asn_ctx),
6160         asn_MAP_ErrorIndication_IEs_tag2el_65,
6161         3,      /* Count of tags in the map */
6162         0, 0, 0,        /* Optional elements (not needed) */
6163         -1,     /* First extension addition */
6164 };
6165 asn_TYPE_descriptor_t asn_DEF_ErrorIndication_IEs = {
6166         "ErrorIndication-IEs",
6167         "ErrorIndication-IEs",
6168         &asn_OP_SEQUENCE,
6169         asn_DEF_ErrorIndication_IEs_tags_65,
6170         sizeof(asn_DEF_ErrorIndication_IEs_tags_65)
6171                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_65[0]), /* 1 */
6172         asn_DEF_ErrorIndication_IEs_tags_65,    /* Same as above */
6173         sizeof(asn_DEF_ErrorIndication_IEs_tags_65)
6174                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_65[0]), /* 1 */
6175         { 0, 0, SEQUENCE_constraint },
6176         asn_MBR_ErrorIndication_IEs_65,
6177         3,      /* Elements count */
6178         &asn_SPC_ErrorIndication_IEs_specs_65   /* Additional specs */
6179 };
6180
6181 static asn_TYPE_member_t asn_MBR_value_72[] = {
6182         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.GlobalE2node_ID),
6183                 -1 /* Ambiguous tag (CHOICE?) */,
6184                 0,
6185                 &asn_DEF_GlobalE2node_ID,
6186                 0,
6187                 { 0, 0, 0 },
6188                 0, 0, /* No default value */
6189                 "GlobalE2node-ID"
6190                 },
6191         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.RANfunctions_List),
6192                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6193                 0,
6194                 &asn_DEF_RANfunctions_List,
6195                 0,
6196                 { 0, 0, 0 },
6197                 0, 0, /* No default value */
6198                 "RANfunctions-List"
6199                 },
6200 };
6201 static const unsigned asn_MAP_value_to_canonical_72[] = { 1, 0 };
6202 static const unsigned asn_MAP_value_from_canonical_72[] = { 1, 0 };
6203 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_72[] = {
6204     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* RANfunctions-List */
6205     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gNB */
6206     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* en-gNB */
6207     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* ng-eNB */
6208     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 } /* eNB */
6209 };
6210 static asn_CHOICE_specifics_t asn_SPC_value_specs_72 = {
6211         sizeof(struct E2setupRequestIEs__value),
6212         offsetof(struct E2setupRequestIEs__value, _asn_ctx),
6213         offsetof(struct E2setupRequestIEs__value, present),
6214         sizeof(((struct E2setupRequestIEs__value *)0)->present),
6215         asn_MAP_value_tag2el_72,
6216         5,      /* Count of tags in the map */
6217         asn_MAP_value_to_canonical_72,
6218         asn_MAP_value_from_canonical_72,
6219         -1      /* Extensions start */
6220 };
6221 static /* Use -fall-defs-global to expose */
6222 asn_TYPE_descriptor_t asn_DEF_value_72 = {
6223         "value",
6224         "value",
6225         &asn_OP_OPEN_TYPE,
6226         0,      /* No effective tags (pointer) */
6227         0,      /* No effective tags (count) */
6228         0,      /* No tags (pointer) */
6229         0,      /* No tags (count) */
6230         { 0, 0, OPEN_TYPE_constraint },
6231         asn_MBR_value_72,
6232         2,      /* Elements count */
6233         &asn_SPC_value_specs_72 /* Additional specs */
6234 };
6235
6236 asn_TYPE_member_t asn_MBR_E2setupRequestIEs_69[] = {
6237         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, id),
6238                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6239                 -1,     /* IMPLICIT tag at current level */
6240                 &asn_DEF_ProtocolIE_ID,
6241                 0,
6242                 { 0, &asn_PER_memb_id_constr_70,  memb_id_constraint_69 },
6243                 0, 0, /* No default value */
6244                 "id"
6245                 },
6246         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, criticality),
6247                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6248                 -1,     /* IMPLICIT tag at current level */
6249                 &asn_DEF_Criticality,
6250                 select_E2setupRequestIEs_criticality_type,
6251                 { 0, &asn_PER_memb_criticality_constr_71,  memb_criticality_constraint_69 },
6252                 0, 0, /* No default value */
6253                 "criticality"
6254                 },
6255         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, value),
6256                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6257                 +1,     /* EXPLICIT tag at current level */
6258                 &asn_DEF_value_72,
6259                 select_E2setupRequestIEs_value_type,
6260                 { 0, &asn_PER_memb_value_constr_72,  memb_value_constraint_69 },
6261                 0, 0, /* No default value */
6262                 "value"
6263                 },
6264 };
6265 static const ber_tlv_tag_t asn_DEF_E2setupRequestIEs_tags_69[] = {
6266         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6267 };
6268 static const asn_TYPE_tag2member_t asn_MAP_E2setupRequestIEs_tag2el_69[] = {
6269     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6270     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6271     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6272 };
6273 asn_SEQUENCE_specifics_t asn_SPC_E2setupRequestIEs_specs_69 = {
6274         sizeof(struct E2setupRequestIEs),
6275         offsetof(struct E2setupRequestIEs, _asn_ctx),
6276         asn_MAP_E2setupRequestIEs_tag2el_69,
6277         3,      /* Count of tags in the map */
6278         0, 0, 0,        /* Optional elements (not needed) */
6279         -1,     /* First extension addition */
6280 };
6281 asn_TYPE_descriptor_t asn_DEF_E2setupRequestIEs = {
6282         "E2setupRequestIEs",
6283         "E2setupRequestIEs",
6284         &asn_OP_SEQUENCE,
6285         asn_DEF_E2setupRequestIEs_tags_69,
6286         sizeof(asn_DEF_E2setupRequestIEs_tags_69)
6287                 /sizeof(asn_DEF_E2setupRequestIEs_tags_69[0]), /* 1 */
6288         asn_DEF_E2setupRequestIEs_tags_69,      /* Same as above */
6289         sizeof(asn_DEF_E2setupRequestIEs_tags_69)
6290                 /sizeof(asn_DEF_E2setupRequestIEs_tags_69[0]), /* 1 */
6291         { 0, 0, SEQUENCE_constraint },
6292         asn_MBR_E2setupRequestIEs_69,
6293         3,      /* Elements count */
6294         &asn_SPC_E2setupRequestIEs_specs_69     /* Additional specs */
6295 };
6296
6297 static asn_TYPE_member_t asn_MBR_value_76[] = {
6298         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.GlobalRIC_ID),
6299                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6300                 0,
6301                 &asn_DEF_GlobalRIC_ID,
6302                 0,
6303                 { 0, 0, 0 },
6304                 0, 0, /* No default value */
6305                 "GlobalRIC-ID"
6306                 },
6307         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsID_List),
6308                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6309                 0,
6310                 &asn_DEF_RANfunctionsID_List,
6311                 0,
6312                 { 0, 0, 0 },
6313                 0, 0, /* No default value */
6314                 "RANfunctionsID-List"
6315                 },
6316         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsIDcause_List),
6317                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6318                 0,
6319                 &asn_DEF_RANfunctionsIDcause_List,
6320                 0,
6321                 { 0, 0, 0 },
6322                 0, 0, /* No default value */
6323                 "RANfunctionsIDcause-List"
6324                 },
6325 };
6326 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_76[] = {
6327     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* GlobalRIC-ID */
6328     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 1 }, /* RANfunctionsID-List */
6329     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -2, 0 } /* RANfunctionsIDcause-List */
6330 };
6331 static asn_CHOICE_specifics_t asn_SPC_value_specs_76 = {
6332         sizeof(struct E2setupResponseIEs__value),
6333         offsetof(struct E2setupResponseIEs__value, _asn_ctx),
6334         offsetof(struct E2setupResponseIEs__value, present),
6335         sizeof(((struct E2setupResponseIEs__value *)0)->present),
6336         asn_MAP_value_tag2el_76,
6337         3,      /* Count of tags in the map */
6338         0, 0,
6339         -1      /* Extensions start */
6340 };
6341 static /* Use -fall-defs-global to expose */
6342 asn_TYPE_descriptor_t asn_DEF_value_76 = {
6343         "value",
6344         "value",
6345         &asn_OP_OPEN_TYPE,
6346         0,      /* No effective tags (pointer) */
6347         0,      /* No effective tags (count) */
6348         0,      /* No tags (pointer) */
6349         0,      /* No tags (count) */
6350         { 0, 0, OPEN_TYPE_constraint },
6351         asn_MBR_value_76,
6352         3,      /* Elements count */
6353         &asn_SPC_value_specs_76 /* Additional specs */
6354 };
6355
6356 asn_TYPE_member_t asn_MBR_E2setupResponseIEs_73[] = {
6357         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, id),
6358                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6359                 -1,     /* IMPLICIT tag at current level */
6360                 &asn_DEF_ProtocolIE_ID,
6361                 0,
6362                 { 0, &asn_PER_memb_id_constr_74,  memb_id_constraint_73 },
6363                 0, 0, /* No default value */
6364                 "id"
6365                 },
6366         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, criticality),
6367                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6368                 -1,     /* IMPLICIT tag at current level */
6369                 &asn_DEF_Criticality,
6370                 select_E2setupResponseIEs_criticality_type,
6371                 { 0, &asn_PER_memb_criticality_constr_75,  memb_criticality_constraint_73 },
6372                 0, 0, /* No default value */
6373                 "criticality"
6374                 },
6375         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, value),
6376                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6377                 +1,     /* EXPLICIT tag at current level */
6378                 &asn_DEF_value_76,
6379                 select_E2setupResponseIEs_value_type,
6380                 { 0, &asn_PER_memb_value_constr_76,  memb_value_constraint_73 },
6381                 0, 0, /* No default value */
6382                 "value"
6383                 },
6384 };
6385 static const ber_tlv_tag_t asn_DEF_E2setupResponseIEs_tags_73[] = {
6386         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6387 };
6388 static const asn_TYPE_tag2member_t asn_MAP_E2setupResponseIEs_tag2el_73[] = {
6389     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6390     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6391     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6392 };
6393 asn_SEQUENCE_specifics_t asn_SPC_E2setupResponseIEs_specs_73 = {
6394         sizeof(struct E2setupResponseIEs),
6395         offsetof(struct E2setupResponseIEs, _asn_ctx),
6396         asn_MAP_E2setupResponseIEs_tag2el_73,
6397         3,      /* Count of tags in the map */
6398         0, 0, 0,        /* Optional elements (not needed) */
6399         -1,     /* First extension addition */
6400 };
6401 asn_TYPE_descriptor_t asn_DEF_E2setupResponseIEs = {
6402         "E2setupResponseIEs",
6403         "E2setupResponseIEs",
6404         &asn_OP_SEQUENCE,
6405         asn_DEF_E2setupResponseIEs_tags_73,
6406         sizeof(asn_DEF_E2setupResponseIEs_tags_73)
6407                 /sizeof(asn_DEF_E2setupResponseIEs_tags_73[0]), /* 1 */
6408         asn_DEF_E2setupResponseIEs_tags_73,     /* Same as above */
6409         sizeof(asn_DEF_E2setupResponseIEs_tags_73)
6410                 /sizeof(asn_DEF_E2setupResponseIEs_tags_73[0]), /* 1 */
6411         { 0, 0, SEQUENCE_constraint },
6412         asn_MBR_E2setupResponseIEs_73,
6413         3,      /* Elements count */
6414         &asn_SPC_E2setupResponseIEs_specs_73    /* Additional specs */
6415 };
6416
6417 static asn_TYPE_member_t asn_MBR_value_80[] = {
6418         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.Cause),
6419                 -1 /* Ambiguous tag (CHOICE?) */,
6420                 0,
6421                 &asn_DEF_Cause,
6422                 0,
6423                 { 0, 0, 0 },
6424                 0, 0, /* No default value */
6425                 "Cause"
6426                 },
6427         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.TimeToWait),
6428                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6429                 0,
6430                 &asn_DEF_TimeToWait,
6431                 0,
6432                 { 0, 0, 0 },
6433                 0, 0, /* No default value */
6434                 "TimeToWait"
6435                 },
6436         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.CriticalityDiagnostics),
6437                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6438                 0,
6439                 &asn_DEF_CriticalityDiagnostics,
6440                 0,
6441                 { 0, 0, 0 },
6442                 0, 0, /* No default value */
6443                 "CriticalityDiagnostics"
6444                 },
6445 };
6446 static const unsigned asn_MAP_value_to_canonical_80[] = { 1, 2, 0 };
6447 static const unsigned asn_MAP_value_from_canonical_80[] = { 2, 0, 1 };
6448 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_80[] = {
6449     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
6450     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 }, /* CriticalityDiagnostics */
6451     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
6452     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
6453     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
6454     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
6455     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
6456 };
6457 static asn_CHOICE_specifics_t asn_SPC_value_specs_80 = {
6458         sizeof(struct E2setupFailureIEs__value),
6459         offsetof(struct E2setupFailureIEs__value, _asn_ctx),
6460         offsetof(struct E2setupFailureIEs__value, present),
6461         sizeof(((struct E2setupFailureIEs__value *)0)->present),
6462         asn_MAP_value_tag2el_80,
6463         7,      /* Count of tags in the map */
6464         asn_MAP_value_to_canonical_80,
6465         asn_MAP_value_from_canonical_80,
6466         -1      /* Extensions start */
6467 };
6468 static /* Use -fall-defs-global to expose */
6469 asn_TYPE_descriptor_t asn_DEF_value_80 = {
6470         "value",
6471         "value",
6472         &asn_OP_OPEN_TYPE,
6473         0,      /* No effective tags (pointer) */
6474         0,      /* No effective tags (count) */
6475         0,      /* No tags (pointer) */
6476         0,      /* No tags (count) */
6477         { 0, 0, OPEN_TYPE_constraint },
6478         asn_MBR_value_80,
6479         3,      /* Elements count */
6480         &asn_SPC_value_specs_80 /* Additional specs */
6481 };
6482
6483 asn_TYPE_member_t asn_MBR_E2setupFailureIEs_77[] = {
6484         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, id),
6485                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6486                 -1,     /* IMPLICIT tag at current level */
6487                 &asn_DEF_ProtocolIE_ID,
6488                 0,
6489                 { 0, &asn_PER_memb_id_constr_78,  memb_id_constraint_77 },
6490                 0, 0, /* No default value */
6491                 "id"
6492                 },
6493         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, criticality),
6494                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6495                 -1,     /* IMPLICIT tag at current level */
6496                 &asn_DEF_Criticality,
6497                 select_E2setupFailureIEs_criticality_type,
6498                 { 0, &asn_PER_memb_criticality_constr_79,  memb_criticality_constraint_77 },
6499                 0, 0, /* No default value */
6500                 "criticality"
6501                 },
6502         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, value),
6503                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6504                 +1,     /* EXPLICIT tag at current level */
6505                 &asn_DEF_value_80,
6506                 select_E2setupFailureIEs_value_type,
6507                 { 0, &asn_PER_memb_value_constr_80,  memb_value_constraint_77 },
6508                 0, 0, /* No default value */
6509                 "value"
6510                 },
6511 };
6512 static const ber_tlv_tag_t asn_DEF_E2setupFailureIEs_tags_77[] = {
6513         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6514 };
6515 static const asn_TYPE_tag2member_t asn_MAP_E2setupFailureIEs_tag2el_77[] = {
6516     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6517     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6518     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6519 };
6520 asn_SEQUENCE_specifics_t asn_SPC_E2setupFailureIEs_specs_77 = {
6521         sizeof(struct E2setupFailureIEs),
6522         offsetof(struct E2setupFailureIEs, _asn_ctx),
6523         asn_MAP_E2setupFailureIEs_tag2el_77,
6524         3,      /* Count of tags in the map */
6525         0, 0, 0,        /* Optional elements (not needed) */
6526         -1,     /* First extension addition */
6527 };
6528 asn_TYPE_descriptor_t asn_DEF_E2setupFailureIEs = {
6529         "E2setupFailureIEs",
6530         "E2setupFailureIEs",
6531         &asn_OP_SEQUENCE,
6532         asn_DEF_E2setupFailureIEs_tags_77,
6533         sizeof(asn_DEF_E2setupFailureIEs_tags_77)
6534                 /sizeof(asn_DEF_E2setupFailureIEs_tags_77[0]), /* 1 */
6535         asn_DEF_E2setupFailureIEs_tags_77,      /* Same as above */
6536         sizeof(asn_DEF_E2setupFailureIEs_tags_77)
6537                 /sizeof(asn_DEF_E2setupFailureIEs_tags_77[0]), /* 1 */
6538         { 0, 0, SEQUENCE_constraint },
6539         asn_MBR_E2setupFailureIEs_77,
6540         3,      /* Elements count */
6541         &asn_SPC_E2setupFailureIEs_specs_77     /* Additional specs */
6542 };
6543
6544 static asn_TYPE_member_t asn_MBR_value_84[] = {
6545         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs__value, choice.Cause),
6546                 -1 /* Ambiguous tag (CHOICE?) */,
6547                 0,
6548                 &asn_DEF_Cause,
6549                 0,
6550                 { 0, 0, 0 },
6551                 0, 0, /* No default value */
6552                 "Cause"
6553                 },
6554 };
6555 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_84[] = {
6556     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
6557     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
6558     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
6559     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
6560     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
6561 };
6562 static asn_CHOICE_specifics_t asn_SPC_value_specs_84 = {
6563         sizeof(struct ResetRequestIEs__value),
6564         offsetof(struct ResetRequestIEs__value, _asn_ctx),
6565         offsetof(struct ResetRequestIEs__value, present),
6566         sizeof(((struct ResetRequestIEs__value *)0)->present),
6567         asn_MAP_value_tag2el_84,
6568         5,      /* Count of tags in the map */
6569         0, 0,
6570         -1      /* Extensions start */
6571 };
6572 static /* Use -fall-defs-global to expose */
6573 asn_TYPE_descriptor_t asn_DEF_value_84 = {
6574         "value",
6575         "value",
6576         &asn_OP_OPEN_TYPE,
6577         0,      /* No effective tags (pointer) */
6578         0,      /* No effective tags (count) */
6579         0,      /* No tags (pointer) */
6580         0,      /* No tags (count) */
6581         { 0, 0, OPEN_TYPE_constraint },
6582         asn_MBR_value_84,
6583         1,      /* Elements count */
6584         &asn_SPC_value_specs_84 /* Additional specs */
6585 };
6586
6587 asn_TYPE_member_t asn_MBR_ResetRequestIEs_81[] = {
6588         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, id),
6589                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6590                 -1,     /* IMPLICIT tag at current level */
6591                 &asn_DEF_ProtocolIE_ID,
6592                 0,
6593                 { 0, &asn_PER_memb_id_constr_82,  memb_id_constraint_81 },
6594                 0, 0, /* No default value */
6595                 "id"
6596                 },
6597         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, criticality),
6598                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6599                 -1,     /* IMPLICIT tag at current level */
6600                 &asn_DEF_Criticality,
6601                 select_ResetRequestIEs_criticality_type,
6602                 { 0, &asn_PER_memb_criticality_constr_83,  memb_criticality_constraint_81 },
6603                 0, 0, /* No default value */
6604                 "criticality"
6605                 },
6606         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, value),
6607                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6608                 +1,     /* EXPLICIT tag at current level */
6609                 &asn_DEF_value_84,
6610                 select_ResetRequestIEs_value_type,
6611                 { 0, &asn_PER_memb_value_constr_84,  memb_value_constraint_81 },
6612                 0, 0, /* No default value */
6613                 "value"
6614                 },
6615 };
6616 static const ber_tlv_tag_t asn_DEF_ResetRequestIEs_tags_81[] = {
6617         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6618 };
6619 static const asn_TYPE_tag2member_t asn_MAP_ResetRequestIEs_tag2el_81[] = {
6620     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6621     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6622     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6623 };
6624 asn_SEQUENCE_specifics_t asn_SPC_ResetRequestIEs_specs_81 = {
6625         sizeof(struct ResetRequestIEs),
6626         offsetof(struct ResetRequestIEs, _asn_ctx),
6627         asn_MAP_ResetRequestIEs_tag2el_81,
6628         3,      /* Count of tags in the map */
6629         0, 0, 0,        /* Optional elements (not needed) */
6630         -1,     /* First extension addition */
6631 };
6632 asn_TYPE_descriptor_t asn_DEF_ResetRequestIEs = {
6633         "ResetRequestIEs",
6634         "ResetRequestIEs",
6635         &asn_OP_SEQUENCE,
6636         asn_DEF_ResetRequestIEs_tags_81,
6637         sizeof(asn_DEF_ResetRequestIEs_tags_81)
6638                 /sizeof(asn_DEF_ResetRequestIEs_tags_81[0]), /* 1 */
6639         asn_DEF_ResetRequestIEs_tags_81,        /* Same as above */
6640         sizeof(asn_DEF_ResetRequestIEs_tags_81)
6641                 /sizeof(asn_DEF_ResetRequestIEs_tags_81[0]), /* 1 */
6642         { 0, 0, SEQUENCE_constraint },
6643         asn_MBR_ResetRequestIEs_81,
6644         3,      /* Elements count */
6645         &asn_SPC_ResetRequestIEs_specs_81       /* Additional specs */
6646 };
6647
6648 static asn_TYPE_member_t asn_MBR_value_88[] = {
6649         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs__value, choice.CriticalityDiagnostics),
6650                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6651                 0,
6652                 &asn_DEF_CriticalityDiagnostics,
6653                 0,
6654                 { 0, 0, 0 },
6655                 0, 0, /* No default value */
6656                 "CriticalityDiagnostics"
6657                 },
6658 };
6659 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_88[] = {
6660     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* CriticalityDiagnostics */
6661 };
6662 static asn_CHOICE_specifics_t asn_SPC_value_specs_88 = {
6663         sizeof(struct ResetResponseIEs__value),
6664         offsetof(struct ResetResponseIEs__value, _asn_ctx),
6665         offsetof(struct ResetResponseIEs__value, present),
6666         sizeof(((struct ResetResponseIEs__value *)0)->present),
6667         asn_MAP_value_tag2el_88,
6668         1,      /* Count of tags in the map */
6669         0, 0,
6670         -1      /* Extensions start */
6671 };
6672 static /* Use -fall-defs-global to expose */
6673 asn_TYPE_descriptor_t asn_DEF_value_88 = {
6674         "value",
6675         "value",
6676         &asn_OP_OPEN_TYPE,
6677         0,      /* No effective tags (pointer) */
6678         0,      /* No effective tags (count) */
6679         0,      /* No tags (pointer) */
6680         0,      /* No tags (count) */
6681         { 0, 0, OPEN_TYPE_constraint },
6682         asn_MBR_value_88,
6683         1,      /* Elements count */
6684         &asn_SPC_value_specs_88 /* Additional specs */
6685 };
6686
6687 asn_TYPE_member_t asn_MBR_ResetResponseIEs_85[] = {
6688         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, id),
6689                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6690                 -1,     /* IMPLICIT tag at current level */
6691                 &asn_DEF_ProtocolIE_ID,
6692                 0,
6693                 { 0, &asn_PER_memb_id_constr_86,  memb_id_constraint_85 },
6694                 0, 0, /* No default value */
6695                 "id"
6696                 },
6697         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, criticality),
6698                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6699                 -1,     /* IMPLICIT tag at current level */
6700                 &asn_DEF_Criticality,
6701                 select_ResetResponseIEs_criticality_type,
6702                 { 0, &asn_PER_memb_criticality_constr_87,  memb_criticality_constraint_85 },
6703                 0, 0, /* No default value */
6704                 "criticality"
6705                 },
6706         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, value),
6707                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6708                 +1,     /* EXPLICIT tag at current level */
6709                 &asn_DEF_value_88,
6710                 select_ResetResponseIEs_value_type,
6711                 { 0, &asn_PER_memb_value_constr_88,  memb_value_constraint_85 },
6712                 0, 0, /* No default value */
6713                 "value"
6714                 },
6715 };
6716 static const ber_tlv_tag_t asn_DEF_ResetResponseIEs_tags_85[] = {
6717         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6718 };
6719 static const asn_TYPE_tag2member_t asn_MAP_ResetResponseIEs_tag2el_85[] = {
6720     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6721     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6722     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6723 };
6724 asn_SEQUENCE_specifics_t asn_SPC_ResetResponseIEs_specs_85 = {
6725         sizeof(struct ResetResponseIEs),
6726         offsetof(struct ResetResponseIEs, _asn_ctx),
6727         asn_MAP_ResetResponseIEs_tag2el_85,
6728         3,      /* Count of tags in the map */
6729         0, 0, 0,        /* Optional elements (not needed) */
6730         -1,     /* First extension addition */
6731 };
6732 asn_TYPE_descriptor_t asn_DEF_ResetResponseIEs = {
6733         "ResetResponseIEs",
6734         "ResetResponseIEs",
6735         &asn_OP_SEQUENCE,
6736         asn_DEF_ResetResponseIEs_tags_85,
6737         sizeof(asn_DEF_ResetResponseIEs_tags_85)
6738                 /sizeof(asn_DEF_ResetResponseIEs_tags_85[0]), /* 1 */
6739         asn_DEF_ResetResponseIEs_tags_85,       /* Same as above */
6740         sizeof(asn_DEF_ResetResponseIEs_tags_85)
6741                 /sizeof(asn_DEF_ResetResponseIEs_tags_85[0]), /* 1 */
6742         { 0, 0, SEQUENCE_constraint },
6743         asn_MBR_ResetResponseIEs_85,
6744         3,      /* Elements count */
6745         &asn_SPC_ResetResponseIEs_specs_85      /* Additional specs */
6746 };
6747
6748 static asn_TYPE_member_t asn_MBR_value_92[] = {
6749         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctions_List),
6750                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6751                 0,
6752                 &asn_DEF_RANfunctions_List,
6753                 0,
6754                 { 0, 0, 0 },
6755                 0, 0, /* No default value */
6756                 "RANfunctions-List"
6757                 },
6758         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctionsID_List),
6759                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6760                 0,
6761                 &asn_DEF_RANfunctionsID_List,
6762                 0,
6763                 { 0, 0, 0 },
6764                 0, 0, /* No default value */
6765                 "RANfunctionsID-List"
6766                 },
6767 };
6768 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_92[] = {
6769     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctions-List */
6770     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsID-List */
6771 };
6772 static asn_CHOICE_specifics_t asn_SPC_value_specs_92 = {
6773         sizeof(struct RICserviceUpdate_IEs__value),
6774         offsetof(struct RICserviceUpdate_IEs__value, _asn_ctx),
6775         offsetof(struct RICserviceUpdate_IEs__value, present),
6776         sizeof(((struct RICserviceUpdate_IEs__value *)0)->present),
6777         asn_MAP_value_tag2el_92,
6778         2,      /* Count of tags in the map */
6779         0, 0,
6780         -1      /* Extensions start */
6781 };
6782 static /* Use -fall-defs-global to expose */
6783 asn_TYPE_descriptor_t asn_DEF_value_92 = {
6784         "value",
6785         "value",
6786         &asn_OP_OPEN_TYPE,
6787         0,      /* No effective tags (pointer) */
6788         0,      /* No effective tags (count) */
6789         0,      /* No tags (pointer) */
6790         0,      /* No tags (count) */
6791         { 0, 0, OPEN_TYPE_constraint },
6792         asn_MBR_value_92,
6793         2,      /* Elements count */
6794         &asn_SPC_value_specs_92 /* Additional specs */
6795 };
6796
6797 asn_TYPE_member_t asn_MBR_RICserviceUpdate_IEs_89[] = {
6798         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, id),
6799                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6800                 -1,     /* IMPLICIT tag at current level */
6801                 &asn_DEF_ProtocolIE_ID,
6802                 0,
6803                 { 0, &asn_PER_memb_id_constr_90,  memb_id_constraint_89 },
6804                 0, 0, /* No default value */
6805                 "id"
6806                 },
6807         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, criticality),
6808                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6809                 -1,     /* IMPLICIT tag at current level */
6810                 &asn_DEF_Criticality,
6811                 select_RICserviceUpdate_IEs_criticality_type,
6812                 { 0, &asn_PER_memb_criticality_constr_91,  memb_criticality_constraint_89 },
6813                 0, 0, /* No default value */
6814                 "criticality"
6815                 },
6816         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, value),
6817                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6818                 +1,     /* EXPLICIT tag at current level */
6819                 &asn_DEF_value_92,
6820                 select_RICserviceUpdate_IEs_value_type,
6821                 { 0, &asn_PER_memb_value_constr_92,  memb_value_constraint_89 },
6822                 0, 0, /* No default value */
6823                 "value"
6824                 },
6825 };
6826 static const ber_tlv_tag_t asn_DEF_RICserviceUpdate_IEs_tags_89[] = {
6827         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6828 };
6829 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdate_IEs_tag2el_89[] = {
6830     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6831     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6832     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6833 };
6834 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdate_IEs_specs_89 = {
6835         sizeof(struct RICserviceUpdate_IEs),
6836         offsetof(struct RICserviceUpdate_IEs, _asn_ctx),
6837         asn_MAP_RICserviceUpdate_IEs_tag2el_89,
6838         3,      /* Count of tags in the map */
6839         0, 0, 0,        /* Optional elements (not needed) */
6840         -1,     /* First extension addition */
6841 };
6842 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdate_IEs = {
6843         "RICserviceUpdate-IEs",
6844         "RICserviceUpdate-IEs",
6845         &asn_OP_SEQUENCE,
6846         asn_DEF_RICserviceUpdate_IEs_tags_89,
6847         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89)
6848                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89[0]), /* 1 */
6849         asn_DEF_RICserviceUpdate_IEs_tags_89,   /* Same as above */
6850         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89)
6851                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89[0]), /* 1 */
6852         { 0, 0, SEQUENCE_constraint },
6853         asn_MBR_RICserviceUpdate_IEs_89,
6854         3,      /* Elements count */
6855         &asn_SPC_RICserviceUpdate_IEs_specs_89  /* Additional specs */
6856 };
6857
6858 static asn_TYPE_member_t asn_MBR_value_96[] = {
6859         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsID_List),
6860                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6861                 0,
6862                 &asn_DEF_RANfunctionsID_List,
6863                 0,
6864                 { 0, 0, 0 },
6865                 0, 0, /* No default value */
6866                 "RANfunctionsID-List"
6867                 },
6868         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsIDcause_List),
6869                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6870                 0,
6871                 &asn_DEF_RANfunctionsIDcause_List,
6872                 0,
6873                 { 0, 0, 0 },
6874                 0, 0, /* No default value */
6875                 "RANfunctionsIDcause-List"
6876                 },
6877 };
6878 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_96[] = {
6879     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsID-List */
6880     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsIDcause-List */
6881 };
6882 static asn_CHOICE_specifics_t asn_SPC_value_specs_96 = {
6883         sizeof(struct RICserviceUpdateAcknowledge_IEs__value),
6884         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, _asn_ctx),
6885         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, present),
6886         sizeof(((struct RICserviceUpdateAcknowledge_IEs__value *)0)->present),
6887         asn_MAP_value_tag2el_96,
6888         2,      /* Count of tags in the map */
6889         0, 0,
6890         -1      /* Extensions start */
6891 };
6892 static /* Use -fall-defs-global to expose */
6893 asn_TYPE_descriptor_t asn_DEF_value_96 = {
6894         "value",
6895         "value",
6896         &asn_OP_OPEN_TYPE,
6897         0,      /* No effective tags (pointer) */
6898         0,      /* No effective tags (count) */
6899         0,      /* No tags (pointer) */
6900         0,      /* No tags (count) */
6901         { 0, 0, OPEN_TYPE_constraint },
6902         asn_MBR_value_96,
6903         2,      /* Elements count */
6904         &asn_SPC_value_specs_96 /* Additional specs */
6905 };
6906
6907 asn_TYPE_member_t asn_MBR_RICserviceUpdateAcknowledge_IEs_93[] = {
6908         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, id),
6909                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6910                 -1,     /* IMPLICIT tag at current level */
6911                 &asn_DEF_ProtocolIE_ID,
6912                 0,
6913                 { 0, &asn_PER_memb_id_constr_94,  memb_id_constraint_93 },
6914                 0, 0, /* No default value */
6915                 "id"
6916                 },
6917         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, criticality),
6918                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6919                 -1,     /* IMPLICIT tag at current level */
6920                 &asn_DEF_Criticality,
6921                 select_RICserviceUpdateAcknowledge_IEs_criticality_type,
6922                 { 0, &asn_PER_memb_criticality_constr_95,  memb_criticality_constraint_93 },
6923                 0, 0, /* No default value */
6924                 "criticality"
6925                 },
6926         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, value),
6927                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6928                 +1,     /* EXPLICIT tag at current level */
6929                 &asn_DEF_value_96,
6930                 select_RICserviceUpdateAcknowledge_IEs_value_type,
6931                 { 0, &asn_PER_memb_value_constr_96,  memb_value_constraint_93 },
6932                 0, 0, /* No default value */
6933                 "value"
6934                 },
6935 };
6936 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[] = {
6937         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6938 };
6939 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_93[] = {
6940     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6941     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6942     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6943 };
6944 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_93 = {
6945         sizeof(struct RICserviceUpdateAcknowledge_IEs),
6946         offsetof(struct RICserviceUpdateAcknowledge_IEs, _asn_ctx),
6947         asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_93,
6948         3,      /* Count of tags in the map */
6949         0, 0, 0,        /* Optional elements (not needed) */
6950         -1,     /* First extension addition */
6951 };
6952 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateAcknowledge_IEs = {
6953         "RICserviceUpdateAcknowledge-IEs",
6954         "RICserviceUpdateAcknowledge-IEs",
6955         &asn_OP_SEQUENCE,
6956         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93,
6957         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93)
6958                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[0]), /* 1 */
6959         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93,        /* Same as above */
6960         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93)
6961                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[0]), /* 1 */
6962         { 0, 0, SEQUENCE_constraint },
6963         asn_MBR_RICserviceUpdateAcknowledge_IEs_93,
6964         3,      /* Elements count */
6965         &asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_93       /* Additional specs */
6966 };
6967
6968 static asn_TYPE_member_t asn_MBR_value_100[] = {
6969         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.RANfunctionsIDcause_List),
6970                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6971                 0,
6972                 &asn_DEF_RANfunctionsIDcause_List,
6973                 0,
6974                 { 0, 0, 0 },
6975                 0, 0, /* No default value */
6976                 "RANfunctionsIDcause-List"
6977                 },
6978         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.TimeToWait),
6979                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6980                 0,
6981                 &asn_DEF_TimeToWait,
6982                 0,
6983                 { 0, 0, 0 },
6984                 0, 0, /* No default value */
6985                 "TimeToWait"
6986                 },
6987         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
6988                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6989                 0,
6990                 &asn_DEF_CriticalityDiagnostics,
6991                 0,
6992                 { 0, 0, 0 },
6993                 0, 0, /* No default value */
6994                 "CriticalityDiagnostics"
6995                 },
6996 };
6997 static const unsigned asn_MAP_value_to_canonical_100[] = { 1, 0, 2 };
6998 static const unsigned asn_MAP_value_from_canonical_100[] = { 1, 0, 2 };
6999 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_100[] = {
7000     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
7001     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsIDcause-List */
7002     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* CriticalityDiagnostics */
7003 };
7004 static asn_CHOICE_specifics_t asn_SPC_value_specs_100 = {
7005         sizeof(struct RICserviceUpdateFailure_IEs__value),
7006         offsetof(struct RICserviceUpdateFailure_IEs__value, _asn_ctx),
7007         offsetof(struct RICserviceUpdateFailure_IEs__value, present),
7008         sizeof(((struct RICserviceUpdateFailure_IEs__value *)0)->present),
7009         asn_MAP_value_tag2el_100,
7010         3,      /* Count of tags in the map */
7011         asn_MAP_value_to_canonical_100,
7012         asn_MAP_value_from_canonical_100,
7013         -1      /* Extensions start */
7014 };
7015 static /* Use -fall-defs-global to expose */
7016 asn_TYPE_descriptor_t asn_DEF_value_100 = {
7017         "value",
7018         "value",
7019         &asn_OP_OPEN_TYPE,
7020         0,      /* No effective tags (pointer) */
7021         0,      /* No effective tags (count) */
7022         0,      /* No tags (pointer) */
7023         0,      /* No tags (count) */
7024         { 0, 0, OPEN_TYPE_constraint },
7025         asn_MBR_value_100,
7026         3,      /* Elements count */
7027         &asn_SPC_value_specs_100        /* Additional specs */
7028 };
7029
7030 asn_TYPE_member_t asn_MBR_RICserviceUpdateFailure_IEs_97[] = {
7031         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, id),
7032                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
7033                 -1,     /* IMPLICIT tag at current level */
7034                 &asn_DEF_ProtocolIE_ID,
7035                 0,
7036                 { 0, &asn_PER_memb_id_constr_98,  memb_id_constraint_97 },
7037                 0, 0, /* No default value */
7038                 "id"
7039                 },
7040         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, criticality),
7041                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
7042                 -1,     /* IMPLICIT tag at current level */
7043                 &asn_DEF_Criticality,
7044                 select_RICserviceUpdateFailure_IEs_criticality_type,
7045                 { 0, &asn_PER_memb_criticality_constr_99,  memb_criticality_constraint_97 },
7046                 0, 0, /* No default value */
7047                 "criticality"
7048                 },
7049         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, value),
7050                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
7051                 +1,     /* EXPLICIT tag at current level */
7052                 &asn_DEF_value_100,
7053                 select_RICserviceUpdateFailure_IEs_value_type,
7054                 { 0, &asn_PER_memb_value_constr_100,  memb_value_constraint_97 },
7055                 0, 0, /* No default value */
7056                 "value"
7057                 },
7058 };
7059 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateFailure_IEs_tags_97[] = {
7060         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7061 };
7062 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateFailure_IEs_tag2el_97[] = {
7063     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
7064     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
7065     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
7066 };
7067 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateFailure_IEs_specs_97 = {
7068         sizeof(struct RICserviceUpdateFailure_IEs),
7069         offsetof(struct RICserviceUpdateFailure_IEs, _asn_ctx),
7070         asn_MAP_RICserviceUpdateFailure_IEs_tag2el_97,
7071         3,      /* Count of tags in the map */
7072         0, 0, 0,        /* Optional elements (not needed) */
7073         -1,     /* First extension addition */
7074 };
7075 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateFailure_IEs = {
7076         "RICserviceUpdateFailure-IEs",
7077         "RICserviceUpdateFailure-IEs",
7078         &asn_OP_SEQUENCE,
7079         asn_DEF_RICserviceUpdateFailure_IEs_tags_97,
7080         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97)
7081                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97[0]), /* 1 */
7082         asn_DEF_RICserviceUpdateFailure_IEs_tags_97,    /* Same as above */
7083         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97)
7084                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97[0]), /* 1 */
7085         { 0, 0, SEQUENCE_constraint },
7086         asn_MBR_RICserviceUpdateFailure_IEs_97,
7087         3,      /* Elements count */
7088         &asn_SPC_RICserviceUpdateFailure_IEs_specs_97   /* Additional specs */
7089 };
7090
7091 static asn_TYPE_member_t asn_MBR_value_104[] = {
7092         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs__value, choice.RANfunctionsID_List),
7093                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7094                 0,
7095                 &asn_DEF_RANfunctionsID_List,
7096                 0,
7097                 { 0, 0, 0 },
7098                 0, 0, /* No default value */
7099                 "RANfunctionsID-List"
7100                 },
7101 };
7102 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_104[] = {
7103     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionsID-List */
7104 };
7105 static asn_CHOICE_specifics_t asn_SPC_value_specs_104 = {
7106         sizeof(struct RICserviceQuery_IEs__value),
7107         offsetof(struct RICserviceQuery_IEs__value, _asn_ctx),
7108         offsetof(struct RICserviceQuery_IEs__value, present),
7109         sizeof(((struct RICserviceQuery_IEs__value *)0)->present),
7110         asn_MAP_value_tag2el_104,
7111         1,      /* Count of tags in the map */
7112         0, 0,
7113         -1      /* Extensions start */
7114 };
7115 static /* Use -fall-defs-global to expose */
7116 asn_TYPE_descriptor_t asn_DEF_value_104 = {
7117         "value",
7118         "value",
7119         &asn_OP_OPEN_TYPE,
7120         0,      /* No effective tags (pointer) */
7121         0,      /* No effective tags (count) */
7122         0,      /* No tags (pointer) */
7123         0,      /* No tags (count) */
7124         { 0, 0, OPEN_TYPE_constraint },
7125         asn_MBR_value_104,
7126         1,      /* Elements count */
7127         &asn_SPC_value_specs_104        /* Additional specs */
7128 };
7129
7130 asn_TYPE_member_t asn_MBR_RICserviceQuery_IEs_101[] = {
7131         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, id),
7132                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
7133                 -1,     /* IMPLICIT tag at current level */
7134                 &asn_DEF_ProtocolIE_ID,
7135                 0,
7136                 { 0, &asn_PER_memb_id_constr_102,  memb_id_constraint_101 },
7137                 0, 0, /* No default value */
7138                 "id"
7139                 },
7140         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, criticality),
7141                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
7142                 -1,     /* IMPLICIT tag at current level */
7143                 &asn_DEF_Criticality,
7144                 select_RICserviceQuery_IEs_criticality_type,
7145                 { 0, &asn_PER_memb_criticality_constr_103,  memb_criticality_constraint_101 },
7146                 0, 0, /* No default value */
7147                 "criticality"
7148                 },
7149         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, value),
7150                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
7151                 +1,     /* EXPLICIT tag at current level */
7152                 &asn_DEF_value_104,
7153                 select_RICserviceQuery_IEs_value_type,
7154                 { 0, &asn_PER_memb_value_constr_104,  memb_value_constraint_101 },
7155                 0, 0, /* No default value */
7156                 "value"
7157                 },
7158 };
7159 static const ber_tlv_tag_t asn_DEF_RICserviceQuery_IEs_tags_101[] = {
7160         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7161 };
7162 static const asn_TYPE_tag2member_t asn_MAP_RICserviceQuery_IEs_tag2el_101[] = {
7163     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
7164     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
7165     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
7166 };
7167 asn_SEQUENCE_specifics_t asn_SPC_RICserviceQuery_IEs_specs_101 = {
7168         sizeof(struct RICserviceQuery_IEs),
7169         offsetof(struct RICserviceQuery_IEs, _asn_ctx),
7170         asn_MAP_RICserviceQuery_IEs_tag2el_101,
7171         3,      /* Count of tags in the map */
7172         0, 0, 0,        /* Optional elements (not needed) */
7173         -1,     /* First extension addition */
7174 };
7175 asn_TYPE_descriptor_t asn_DEF_RICserviceQuery_IEs = {
7176         "RICserviceQuery-IEs",
7177         "RICserviceQuery-IEs",
7178         &asn_OP_SEQUENCE,
7179         asn_DEF_RICserviceQuery_IEs_tags_101,
7180         sizeof(asn_DEF_RICserviceQuery_IEs_tags_101)
7181                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_101[0]), /* 1 */
7182         asn_DEF_RICserviceQuery_IEs_tags_101,   /* Same as above */
7183         sizeof(asn_DEF_RICserviceQuery_IEs_tags_101)
7184                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_101[0]), /* 1 */
7185         { 0, 0, SEQUENCE_constraint },
7186         asn_MBR_RICserviceQuery_IEs_101,
7187         3,      /* Elements count */
7188         &asn_SPC_RICserviceQuery_IEs_specs_101  /* Additional specs */
7189 };
7190