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