RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-Field.c

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