e2sim/src/ASN1c/ProtocolIE-Field.c

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