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

   1 /*
   2  *
   3  * Copyright 2020 AT&T Intellectual Property
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 /*
  20  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  21  * From ASN.1 module "E2AP-Containers"
  22  *      found in "../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
2080         if((value >= 0 && value <= 65535)) {
2081                 /* Constraint check succeeded */
2082                 return 0;
2083         } else {
2084                 ASN__CTFAIL(app_key, td, sptr,
2085                         "%s: constraint failed (%s:%d)",
2086                         td->name, __FILE__, __LINE__);
2087                 return -1;
2088         }
2089 }
2090
2091 static asn_type_selector_result_t
2092 select_RICindication_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2093         asn_type_selector_result_t result = {0, 0};
2094         const asn_ioc_set_t *itable = asn_IOS_RICindication_IEs_1;
2095         size_t constraining_column = 0; /* &id */
2096         size_t for_column = 1; /* &criticality */
2097         size_t row, presence_index = 0;
2098         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICindication_IEs, id));
2099
2100         for(row=0; row < itable->rows_count; row++) {
2101             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2102             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2103
2104             if(type_cell->cell_kind == aioc__undefined)
2105                 continue;
2106
2107             presence_index++;
2108             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2109                 result.type_descriptor = type_cell->type_descriptor;
2110                 result.presence_index = presence_index;
2111                 break;
2112             }
2113         }
2114
2115         return result;
2116 }
2117
2118 static int
2119 memb_criticality_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2120                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2121
2122         if(!sptr) {
2123                 ASN__CTFAIL(app_key, td, sptr,
2124                         "%s: value not given (%s:%d)",
2125                         td->name, __FILE__, __LINE__);
2126                 return -1;
2127         }
2128
2129
2130         if(1 /* No applicable constraints whatsoever */) {
2131                 /* Nothing is here. See below */
2132         }
2133
2134         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2135 }
2136
2137 static asn_type_selector_result_t
2138 select_RICindication_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2139         asn_type_selector_result_t result = {0, 0};
2140         const asn_ioc_set_t *itable = asn_IOS_RICindication_IEs_1;
2141         size_t constraining_column = 0; /* &id */
2142         size_t for_column = 2; /* &Value */
2143         size_t row, presence_index = 0;
2144         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICindication_IEs, id));
2145
2146         for(row=0; row < itable->rows_count; row++) {
2147             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2148             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2149
2150             if(type_cell->cell_kind == aioc__undefined)
2151                 continue;
2152
2153             presence_index++;
2154             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2155                 result.type_descriptor = type_cell->type_descriptor;
2156                 result.presence_index = presence_index;
2157                 break;
2158             }
2159         }
2160
2161         return result;
2162 }
2163
2164 static int
2165 memb_value_constraint_49(const asn_TYPE_descriptor_t *td, const void *sptr,
2166                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2167
2168         if(!sptr) {
2169                 ASN__CTFAIL(app_key, td, sptr,
2170                         "%s: value not given (%s:%d)",
2171                         td->name, __FILE__, __LINE__);
2172                 return -1;
2173         }
2174
2175
2176         if(1 /* No applicable constraints whatsoever */) {
2177                 /* Nothing is here. See below */
2178         }
2179
2180         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2181 }
2182
2183 static int
2184 memb_id_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2185                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2186         long value;
2187
2188         if(!sptr) {
2189                 ASN__CTFAIL(app_key, td, sptr,
2190                         "%s: value not given (%s:%d)",
2191                         td->name, __FILE__, __LINE__);
2192                 return -1;
2193         }
2194
2195         value = *(const long *)sptr;
2196
2197         if((value >= 0 && value <= 65535)) {
2198                 /* Constraint check succeeded */
2199                 return 0;
2200         } else {
2201                 ASN__CTFAIL(app_key, td, sptr,
2202                         "%s: constraint failed (%s:%d)",
2203                         td->name, __FILE__, __LINE__);
2204                 return -1;
2205         }
2206 }
2207
2208 static asn_type_selector_result_t
2209 select_RICcontrolRequest_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2210         asn_type_selector_result_t result = {0, 0};
2211         const asn_ioc_set_t *itable = asn_IOS_RICcontrolRequest_IEs_1;
2212         size_t constraining_column = 0; /* &id */
2213         size_t for_column = 1; /* &criticality */
2214         size_t row, presence_index = 0;
2215         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolRequest_IEs, id));
2216
2217         for(row=0; row < itable->rows_count; row++) {
2218             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2219             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2220
2221             if(type_cell->cell_kind == aioc__undefined)
2222                 continue;
2223
2224             presence_index++;
2225             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2226                 result.type_descriptor = type_cell->type_descriptor;
2227                 result.presence_index = presence_index;
2228                 break;
2229             }
2230         }
2231
2232         return result;
2233 }
2234
2235 static int
2236 memb_criticality_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2237                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2238
2239         if(!sptr) {
2240                 ASN__CTFAIL(app_key, td, sptr,
2241                         "%s: value not given (%s:%d)",
2242                         td->name, __FILE__, __LINE__);
2243                 return -1;
2244         }
2245
2246
2247         if(1 /* No applicable constraints whatsoever */) {
2248                 /* Nothing is here. See below */
2249         }
2250
2251         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2252 }
2253
2254 static asn_type_selector_result_t
2255 select_RICcontrolRequest_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2256         asn_type_selector_result_t result = {0, 0};
2257         const asn_ioc_set_t *itable = asn_IOS_RICcontrolRequest_IEs_1;
2258         size_t constraining_column = 0; /* &id */
2259         size_t for_column = 2; /* &Value */
2260         size_t row, presence_index = 0;
2261         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolRequest_IEs, id));
2262
2263         for(row=0; row < itable->rows_count; row++) {
2264             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2265             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2266
2267             if(type_cell->cell_kind == aioc__undefined)
2268                 continue;
2269
2270             presence_index++;
2271             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2272                 result.type_descriptor = type_cell->type_descriptor;
2273                 result.presence_index = presence_index;
2274                 break;
2275             }
2276         }
2277
2278         return result;
2279 }
2280
2281 static int
2282 memb_value_constraint_53(const asn_TYPE_descriptor_t *td, const void *sptr,
2283                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2284
2285         if(!sptr) {
2286                 ASN__CTFAIL(app_key, td, sptr,
2287                         "%s: value not given (%s:%d)",
2288                         td->name, __FILE__, __LINE__);
2289                 return -1;
2290         }
2291
2292
2293         if(1 /* No applicable constraints whatsoever */) {
2294                 /* Nothing is here. See below */
2295         }
2296
2297         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2298 }
2299
2300 static int
2301 memb_id_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2302                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2303         long value;
2304
2305         if(!sptr) {
2306                 ASN__CTFAIL(app_key, td, sptr,
2307                         "%s: value not given (%s:%d)",
2308                         td->name, __FILE__, __LINE__);
2309                 return -1;
2310         }
2311
2312         value = *(const long *)sptr;
2313
2314         if((value >= 0 && value <= 65535)) {
2315                 /* Constraint check succeeded */
2316                 return 0;
2317         } else {
2318                 ASN__CTFAIL(app_key, td, sptr,
2319                         "%s: constraint failed (%s:%d)",
2320                         td->name, __FILE__, __LINE__);
2321                 return -1;
2322         }
2323 }
2324
2325 static asn_type_selector_result_t
2326 select_RICcontrolAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2327         asn_type_selector_result_t result = {0, 0};
2328         const asn_ioc_set_t *itable = asn_IOS_RICcontrolAcknowledge_IEs_1;
2329         size_t constraining_column = 0; /* &id */
2330         size_t for_column = 1; /* &criticality */
2331         size_t row, presence_index = 0;
2332         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolAcknowledge_IEs, id));
2333
2334         for(row=0; row < itable->rows_count; row++) {
2335             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2336             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2337
2338             if(type_cell->cell_kind == aioc__undefined)
2339                 continue;
2340
2341             presence_index++;
2342             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2343                 result.type_descriptor = type_cell->type_descriptor;
2344                 result.presence_index = presence_index;
2345                 break;
2346             }
2347         }
2348
2349         return result;
2350 }
2351
2352 static int
2353 memb_criticality_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2354                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2355
2356         if(!sptr) {
2357                 ASN__CTFAIL(app_key, td, sptr,
2358                         "%s: value not given (%s:%d)",
2359                         td->name, __FILE__, __LINE__);
2360                 return -1;
2361         }
2362
2363
2364         if(1 /* No applicable constraints whatsoever */) {
2365                 /* Nothing is here. See below */
2366         }
2367
2368         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2369 }
2370
2371 static asn_type_selector_result_t
2372 select_RICcontrolAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2373         asn_type_selector_result_t result = {0, 0};
2374         const asn_ioc_set_t *itable = asn_IOS_RICcontrolAcknowledge_IEs_1;
2375         size_t constraining_column = 0; /* &id */
2376         size_t for_column = 2; /* &Value */
2377         size_t row, presence_index = 0;
2378         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolAcknowledge_IEs, id));
2379
2380         for(row=0; row < itable->rows_count; row++) {
2381             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2382             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2383
2384             if(type_cell->cell_kind == aioc__undefined)
2385                 continue;
2386
2387             presence_index++;
2388             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2389                 result.type_descriptor = type_cell->type_descriptor;
2390                 result.presence_index = presence_index;
2391                 break;
2392             }
2393         }
2394
2395         return result;
2396 }
2397
2398 static int
2399 memb_value_constraint_57(const asn_TYPE_descriptor_t *td, const void *sptr,
2400                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2401
2402         if(!sptr) {
2403                 ASN__CTFAIL(app_key, td, sptr,
2404                         "%s: value not given (%s:%d)",
2405                         td->name, __FILE__, __LINE__);
2406                 return -1;
2407         }
2408
2409
2410         if(1 /* No applicable constraints whatsoever */) {
2411                 /* Nothing is here. See below */
2412         }
2413
2414         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2415 }
2416
2417 static int
2418 memb_id_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2419                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2420         long value;
2421
2422         if(!sptr) {
2423                 ASN__CTFAIL(app_key, td, sptr,
2424                         "%s: value not given (%s:%d)",
2425                         td->name, __FILE__, __LINE__);
2426                 return -1;
2427         }
2428
2429         value = *(const long *)sptr;
2430
2431         if((value >= 0 && value <= 65535)) {
2432                 /* Constraint check succeeded */
2433                 return 0;
2434         } else {
2435                 ASN__CTFAIL(app_key, td, sptr,
2436                         "%s: constraint failed (%s:%d)",
2437                         td->name, __FILE__, __LINE__);
2438                 return -1;
2439         }
2440 }
2441
2442 static asn_type_selector_result_t
2443 select_RICcontrolFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2444         asn_type_selector_result_t result = {0, 0};
2445         const asn_ioc_set_t *itable = asn_IOS_RICcontrolFailure_IEs_1;
2446         size_t constraining_column = 0; /* &id */
2447         size_t for_column = 1; /* &criticality */
2448         size_t row, presence_index = 0;
2449         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolFailure_IEs, id));
2450
2451         for(row=0; row < itable->rows_count; row++) {
2452             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2453             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2454
2455             if(type_cell->cell_kind == aioc__undefined)
2456                 continue;
2457
2458             presence_index++;
2459             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2460                 result.type_descriptor = type_cell->type_descriptor;
2461                 result.presence_index = presence_index;
2462                 break;
2463             }
2464         }
2465
2466         return result;
2467 }
2468
2469 static int
2470 memb_criticality_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2471                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2472
2473         if(!sptr) {
2474                 ASN__CTFAIL(app_key, td, sptr,
2475                         "%s: value not given (%s:%d)",
2476                         td->name, __FILE__, __LINE__);
2477                 return -1;
2478         }
2479
2480
2481         if(1 /* No applicable constraints whatsoever */) {
2482                 /* Nothing is here. See below */
2483         }
2484
2485         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2486 }
2487
2488 static asn_type_selector_result_t
2489 select_RICcontrolFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2490         asn_type_selector_result_t result = {0, 0};
2491         const asn_ioc_set_t *itable = asn_IOS_RICcontrolFailure_IEs_1;
2492         size_t constraining_column = 0; /* &id */
2493         size_t for_column = 2; /* &Value */
2494         size_t row, presence_index = 0;
2495         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICcontrolFailure_IEs, id));
2496
2497         for(row=0; row < itable->rows_count; row++) {
2498             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2499             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2500
2501             if(type_cell->cell_kind == aioc__undefined)
2502                 continue;
2503
2504             presence_index++;
2505             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2506                 result.type_descriptor = type_cell->type_descriptor;
2507                 result.presence_index = presence_index;
2508                 break;
2509             }
2510         }
2511
2512         return result;
2513 }
2514
2515 static int
2516 memb_value_constraint_61(const asn_TYPE_descriptor_t *td, const void *sptr,
2517                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2518
2519         if(!sptr) {
2520                 ASN__CTFAIL(app_key, td, sptr,
2521                         "%s: value not given (%s:%d)",
2522                         td->name, __FILE__, __LINE__);
2523                 return -1;
2524         }
2525
2526
2527         if(1 /* No applicable constraints whatsoever */) {
2528                 /* Nothing is here. See below */
2529         }
2530
2531         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2532 }
2533
2534 static int
2535 memb_id_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2536                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2537         long value;
2538
2539         if(!sptr) {
2540                 ASN__CTFAIL(app_key, td, sptr,
2541                         "%s: value not given (%s:%d)",
2542                         td->name, __FILE__, __LINE__);
2543                 return -1;
2544         }
2545
2546         value = *(const long *)sptr;
2547
2548         if((value >= 0 && value <= 65535)) {
2549                 /* Constraint check succeeded */
2550                 return 0;
2551         } else {
2552                 ASN__CTFAIL(app_key, td, sptr,
2553                         "%s: constraint failed (%s:%d)",
2554                         td->name, __FILE__, __LINE__);
2555                 return -1;
2556         }
2557 }
2558
2559 static asn_type_selector_result_t
2560 select_ErrorIndication_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2561         asn_type_selector_result_t result = {0, 0};
2562         const asn_ioc_set_t *itable = asn_IOS_ErrorIndication_IEs_1;
2563         size_t constraining_column = 0; /* &id */
2564         size_t for_column = 1; /* &criticality */
2565         size_t row, presence_index = 0;
2566         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ErrorIndication_IEs, id));
2567
2568         for(row=0; row < itable->rows_count; row++) {
2569             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2570             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2571
2572             if(type_cell->cell_kind == aioc__undefined)
2573                 continue;
2574
2575             presence_index++;
2576             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2577                 result.type_descriptor = type_cell->type_descriptor;
2578                 result.presence_index = presence_index;
2579                 break;
2580             }
2581         }
2582
2583         return result;
2584 }
2585
2586 static int
2587 memb_criticality_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2588                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2589
2590         if(!sptr) {
2591                 ASN__CTFAIL(app_key, td, sptr,
2592                         "%s: value not given (%s:%d)",
2593                         td->name, __FILE__, __LINE__);
2594                 return -1;
2595         }
2596
2597
2598         if(1 /* No applicable constraints whatsoever */) {
2599                 /* Nothing is here. See below */
2600         }
2601
2602         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2603 }
2604
2605 static asn_type_selector_result_t
2606 select_ErrorIndication_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2607         asn_type_selector_result_t result = {0, 0};
2608         const asn_ioc_set_t *itable = asn_IOS_ErrorIndication_IEs_1;
2609         size_t constraining_column = 0; /* &id */
2610         size_t for_column = 2; /* &Value */
2611         size_t row, presence_index = 0;
2612         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ErrorIndication_IEs, id));
2613
2614         for(row=0; row < itable->rows_count; row++) {
2615             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2616             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2617
2618             if(type_cell->cell_kind == aioc__undefined)
2619                 continue;
2620
2621             presence_index++;
2622             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2623                 result.type_descriptor = type_cell->type_descriptor;
2624                 result.presence_index = presence_index;
2625                 break;
2626             }
2627         }
2628
2629         return result;
2630 }
2631
2632 static int
2633 memb_value_constraint_65(const asn_TYPE_descriptor_t *td, const void *sptr,
2634                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2635
2636         if(!sptr) {
2637                 ASN__CTFAIL(app_key, td, sptr,
2638                         "%s: value not given (%s:%d)",
2639                         td->name, __FILE__, __LINE__);
2640                 return -1;
2641         }
2642
2643
2644         if(1 /* No applicable constraints whatsoever */) {
2645                 /* Nothing is here. See below */
2646         }
2647
2648         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2649 }
2650
2651 static int
2652 memb_id_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2653                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2654         long value;
2655
2656         if(!sptr) {
2657                 ASN__CTFAIL(app_key, td, sptr,
2658                         "%s: value not given (%s:%d)",
2659                         td->name, __FILE__, __LINE__);
2660                 return -1;
2661         }
2662
2663         value = *(const long *)sptr;
2664
2665         if((value >= 0 && value <= 65535)) {
2666                 /* Constraint check succeeded */
2667                 return 0;
2668         } else {
2669                 ASN__CTFAIL(app_key, td, sptr,
2670                         "%s: constraint failed (%s:%d)",
2671                         td->name, __FILE__, __LINE__);
2672                 return -1;
2673         }
2674 }
2675
2676 static asn_type_selector_result_t
2677 select_E2setupRequestIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2678         asn_type_selector_result_t result = {0, 0};
2679         const asn_ioc_set_t *itable = asn_IOS_E2setupRequestIEs_1;
2680         size_t constraining_column = 0; /* &id */
2681         size_t for_column = 1; /* &criticality */
2682         size_t row, presence_index = 0;
2683         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupRequestIEs, id));
2684
2685         for(row=0; row < itable->rows_count; row++) {
2686             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2687             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2688
2689             if(type_cell->cell_kind == aioc__undefined)
2690                 continue;
2691
2692             presence_index++;
2693             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2694                 result.type_descriptor = type_cell->type_descriptor;
2695                 result.presence_index = presence_index;
2696                 break;
2697             }
2698         }
2699
2700         return result;
2701 }
2702
2703 static int
2704 memb_criticality_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2705                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2706
2707         if(!sptr) {
2708                 ASN__CTFAIL(app_key, td, sptr,
2709                         "%s: value not given (%s:%d)",
2710                         td->name, __FILE__, __LINE__);
2711                 return -1;
2712         }
2713
2714
2715         if(1 /* No applicable constraints whatsoever */) {
2716                 /* Nothing is here. See below */
2717         }
2718
2719         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2720 }
2721
2722 static asn_type_selector_result_t
2723 select_E2setupRequestIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2724         asn_type_selector_result_t result = {0, 0};
2725         const asn_ioc_set_t *itable = asn_IOS_E2setupRequestIEs_1;
2726         size_t constraining_column = 0; /* &id */
2727         size_t for_column = 2; /* &Value */
2728         size_t row, presence_index = 0;
2729         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupRequestIEs, id));
2730
2731         for(row=0; row < itable->rows_count; row++) {
2732             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2733             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2734
2735             if(type_cell->cell_kind == aioc__undefined)
2736                 continue;
2737
2738             presence_index++;
2739             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2740                 result.type_descriptor = type_cell->type_descriptor;
2741                 result.presence_index = presence_index;
2742                 break;
2743             }
2744         }
2745
2746         return result;
2747 }
2748
2749 static int
2750 memb_value_constraint_69(const asn_TYPE_descriptor_t *td, const void *sptr,
2751                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2752
2753         if(!sptr) {
2754                 ASN__CTFAIL(app_key, td, sptr,
2755                         "%s: value not given (%s:%d)",
2756                         td->name, __FILE__, __LINE__);
2757                 return -1;
2758         }
2759
2760
2761         if(1 /* No applicable constraints whatsoever */) {
2762                 /* Nothing is here. See below */
2763         }
2764
2765         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2766 }
2767
2768 static int
2769 memb_id_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2770                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2771         long value;
2772
2773         if(!sptr) {
2774                 ASN__CTFAIL(app_key, td, sptr,
2775                         "%s: value not given (%s:%d)",
2776                         td->name, __FILE__, __LINE__);
2777                 return -1;
2778         }
2779
2780         value = *(const long *)sptr;
2781
2782         if((value >= 0 && value <= 65535)) {
2783                 /* Constraint check succeeded */
2784                 return 0;
2785         } else {
2786                 ASN__CTFAIL(app_key, td, sptr,
2787                         "%s: constraint failed (%s:%d)",
2788                         td->name, __FILE__, __LINE__);
2789                 return -1;
2790         }
2791 }
2792
2793 static asn_type_selector_result_t
2794 select_E2setupResponseIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2795         asn_type_selector_result_t result = {0, 0};
2796         const asn_ioc_set_t *itable = asn_IOS_E2setupResponseIEs_1;
2797         size_t constraining_column = 0; /* &id */
2798         size_t for_column = 1; /* &criticality */
2799         size_t row, presence_index = 0;
2800         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupResponseIEs, id));
2801
2802         for(row=0; row < itable->rows_count; row++) {
2803             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2804             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2805
2806             if(type_cell->cell_kind == aioc__undefined)
2807                 continue;
2808
2809             presence_index++;
2810             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2811                 result.type_descriptor = type_cell->type_descriptor;
2812                 result.presence_index = presence_index;
2813                 break;
2814             }
2815         }
2816
2817         return result;
2818 }
2819
2820 static int
2821 memb_criticality_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2822                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2823
2824         if(!sptr) {
2825                 ASN__CTFAIL(app_key, td, sptr,
2826                         "%s: value not given (%s:%d)",
2827                         td->name, __FILE__, __LINE__);
2828                 return -1;
2829         }
2830
2831
2832         if(1 /* No applicable constraints whatsoever */) {
2833                 /* Nothing is here. See below */
2834         }
2835
2836         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2837 }
2838
2839 static asn_type_selector_result_t
2840 select_E2setupResponseIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2841         asn_type_selector_result_t result = {0, 0};
2842         const asn_ioc_set_t *itable = asn_IOS_E2setupResponseIEs_1;
2843         size_t constraining_column = 0; /* &id */
2844         size_t for_column = 2; /* &Value */
2845         size_t row, presence_index = 0;
2846         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupResponseIEs, id));
2847
2848         for(row=0; row < itable->rows_count; row++) {
2849             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2850             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2851
2852             if(type_cell->cell_kind == aioc__undefined)
2853                 continue;
2854
2855             presence_index++;
2856             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2857                 result.type_descriptor = type_cell->type_descriptor;
2858                 result.presence_index = presence_index;
2859                 break;
2860             }
2861         }
2862
2863         return result;
2864 }
2865
2866 static int
2867 memb_value_constraint_73(const asn_TYPE_descriptor_t *td, const void *sptr,
2868                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2869
2870         if(!sptr) {
2871                 ASN__CTFAIL(app_key, td, sptr,
2872                         "%s: value not given (%s:%d)",
2873                         td->name, __FILE__, __LINE__);
2874                 return -1;
2875         }
2876
2877
2878         if(1 /* No applicable constraints whatsoever */) {
2879                 /* Nothing is here. See below */
2880         }
2881
2882         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2883 }
2884
2885 static int
2886 memb_id_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2887                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2888         long value;
2889
2890         if(!sptr) {
2891                 ASN__CTFAIL(app_key, td, sptr,
2892                         "%s: value not given (%s:%d)",
2893                         td->name, __FILE__, __LINE__);
2894                 return -1;
2895         }
2896
2897         value = *(const long *)sptr;
2898
2899         if((value >= 0 && value <= 65535)) {
2900                 /* Constraint check succeeded */
2901                 return 0;
2902         } else {
2903                 ASN__CTFAIL(app_key, td, sptr,
2904                         "%s: constraint failed (%s:%d)",
2905                         td->name, __FILE__, __LINE__);
2906                 return -1;
2907         }
2908 }
2909
2910 static asn_type_selector_result_t
2911 select_E2setupFailureIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2912         asn_type_selector_result_t result = {0, 0};
2913         const asn_ioc_set_t *itable = asn_IOS_E2setupFailureIEs_1;
2914         size_t constraining_column = 0; /* &id */
2915         size_t for_column = 1; /* &criticality */
2916         size_t row, presence_index = 0;
2917         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupFailureIEs, id));
2918
2919         for(row=0; row < itable->rows_count; row++) {
2920             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2921             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2922
2923             if(type_cell->cell_kind == aioc__undefined)
2924                 continue;
2925
2926             presence_index++;
2927             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2928                 result.type_descriptor = type_cell->type_descriptor;
2929                 result.presence_index = presence_index;
2930                 break;
2931             }
2932         }
2933
2934         return result;
2935 }
2936
2937 static int
2938 memb_criticality_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2939                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2940
2941         if(!sptr) {
2942                 ASN__CTFAIL(app_key, td, sptr,
2943                         "%s: value not given (%s:%d)",
2944                         td->name, __FILE__, __LINE__);
2945                 return -1;
2946         }
2947
2948
2949         if(1 /* No applicable constraints whatsoever */) {
2950                 /* Nothing is here. See below */
2951         }
2952
2953         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
2954 }
2955
2956 static asn_type_selector_result_t
2957 select_E2setupFailureIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
2958         asn_type_selector_result_t result = {0, 0};
2959         const asn_ioc_set_t *itable = asn_IOS_E2setupFailureIEs_1;
2960         size_t constraining_column = 0; /* &id */
2961         size_t for_column = 2; /* &Value */
2962         size_t row, presence_index = 0;
2963         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct E2setupFailureIEs, id));
2964
2965         for(row=0; row < itable->rows_count; row++) {
2966             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
2967             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
2968
2969             if(type_cell->cell_kind == aioc__undefined)
2970                 continue;
2971
2972             presence_index++;
2973             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
2974                 result.type_descriptor = type_cell->type_descriptor;
2975                 result.presence_index = presence_index;
2976                 break;
2977             }
2978         }
2979
2980         return result;
2981 }
2982
2983 static int
2984 memb_value_constraint_77(const asn_TYPE_descriptor_t *td, const void *sptr,
2985                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
2986
2987         if(!sptr) {
2988                 ASN__CTFAIL(app_key, td, sptr,
2989                         "%s: value not given (%s:%d)",
2990                         td->name, __FILE__, __LINE__);
2991                 return -1;
2992         }
2993
2994
2995         if(1 /* No applicable constraints whatsoever */) {
2996                 /* Nothing is here. See below */
2997         }
2998
2999         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3000 }
3001
3002 static int
3003 memb_id_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3004                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3005         long value;
3006
3007         if(!sptr) {
3008                 ASN__CTFAIL(app_key, td, sptr,
3009                         "%s: value not given (%s:%d)",
3010                         td->name, __FILE__, __LINE__);
3011                 return -1;
3012         }
3013
3014         value = *(const long *)sptr;
3015
3016         if((value >= 0 && value <= 65535)) {
3017                 /* Constraint check succeeded */
3018                 return 0;
3019         } else {
3020                 ASN__CTFAIL(app_key, td, sptr,
3021                         "%s: constraint failed (%s:%d)",
3022                         td->name, __FILE__, __LINE__);
3023                 return -1;
3024         }
3025 }
3026
3027 static asn_type_selector_result_t
3028 select_ResetRequestIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3029         asn_type_selector_result_t result = {0, 0};
3030         const asn_ioc_set_t *itable = asn_IOS_ResetRequestIEs_1;
3031         size_t constraining_column = 0; /* &id */
3032         size_t for_column = 1; /* &criticality */
3033         size_t row, presence_index = 0;
3034         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetRequestIEs, id));
3035
3036         for(row=0; row < itable->rows_count; row++) {
3037             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3038             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3039
3040             if(type_cell->cell_kind == aioc__undefined)
3041                 continue;
3042
3043             presence_index++;
3044             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3045                 result.type_descriptor = type_cell->type_descriptor;
3046                 result.presence_index = presence_index;
3047                 break;
3048             }
3049         }
3050
3051         return result;
3052 }
3053
3054 static int
3055 memb_criticality_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3056                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3057
3058         if(!sptr) {
3059                 ASN__CTFAIL(app_key, td, sptr,
3060                         "%s: value not given (%s:%d)",
3061                         td->name, __FILE__, __LINE__);
3062                 return -1;
3063         }
3064
3065
3066         if(1 /* No applicable constraints whatsoever */) {
3067                 /* Nothing is here. See below */
3068         }
3069
3070         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3071 }
3072
3073 static asn_type_selector_result_t
3074 select_ResetRequestIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3075         asn_type_selector_result_t result = {0, 0};
3076         const asn_ioc_set_t *itable = asn_IOS_ResetRequestIEs_1;
3077         size_t constraining_column = 0; /* &id */
3078         size_t for_column = 2; /* &Value */
3079         size_t row, presence_index = 0;
3080         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetRequestIEs, id));
3081
3082         for(row=0; row < itable->rows_count; row++) {
3083             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3084             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3085
3086             if(type_cell->cell_kind == aioc__undefined)
3087                 continue;
3088
3089             presence_index++;
3090             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3091                 result.type_descriptor = type_cell->type_descriptor;
3092                 result.presence_index = presence_index;
3093                 break;
3094             }
3095         }
3096
3097         return result;
3098 }
3099
3100 static int
3101 memb_value_constraint_81(const asn_TYPE_descriptor_t *td, const void *sptr,
3102                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3103
3104         if(!sptr) {
3105                 ASN__CTFAIL(app_key, td, sptr,
3106                         "%s: value not given (%s:%d)",
3107                         td->name, __FILE__, __LINE__);
3108                 return -1;
3109         }
3110
3111
3112         if(1 /* No applicable constraints whatsoever */) {
3113                 /* Nothing is here. See below */
3114         }
3115
3116         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3117 }
3118
3119 static int
3120 memb_id_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3121                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3122         long value;
3123
3124         if(!sptr) {
3125                 ASN__CTFAIL(app_key, td, sptr,
3126                         "%s: value not given (%s:%d)",
3127                         td->name, __FILE__, __LINE__);
3128                 return -1;
3129         }
3130
3131         value = *(const long *)sptr;
3132
3133         if((value >= 0 && value <= 65535)) {
3134                 /* Constraint check succeeded */
3135                 return 0;
3136         } else {
3137                 ASN__CTFAIL(app_key, td, sptr,
3138                         "%s: constraint failed (%s:%d)",
3139                         td->name, __FILE__, __LINE__);
3140                 return -1;
3141         }
3142 }
3143
3144 static asn_type_selector_result_t
3145 select_ResetResponseIEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3146         asn_type_selector_result_t result = {0, 0};
3147         const asn_ioc_set_t *itable = asn_IOS_ResetResponseIEs_1;
3148         size_t constraining_column = 0; /* &id */
3149         size_t for_column = 1; /* &criticality */
3150         size_t row, presence_index = 0;
3151         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetResponseIEs, id));
3152
3153         for(row=0; row < itable->rows_count; row++) {
3154             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3155             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3156
3157             if(type_cell->cell_kind == aioc__undefined)
3158                 continue;
3159
3160             presence_index++;
3161             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3162                 result.type_descriptor = type_cell->type_descriptor;
3163                 result.presence_index = presence_index;
3164                 break;
3165             }
3166         }
3167
3168         return result;
3169 }
3170
3171 static int
3172 memb_criticality_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3173                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3174
3175         if(!sptr) {
3176                 ASN__CTFAIL(app_key, td, sptr,
3177                         "%s: value not given (%s:%d)",
3178                         td->name, __FILE__, __LINE__);
3179                 return -1;
3180         }
3181
3182
3183         if(1 /* No applicable constraints whatsoever */) {
3184                 /* Nothing is here. See below */
3185         }
3186
3187         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3188 }
3189
3190 static asn_type_selector_result_t
3191 select_ResetResponseIEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3192         asn_type_selector_result_t result = {0, 0};
3193         const asn_ioc_set_t *itable = asn_IOS_ResetResponseIEs_1;
3194         size_t constraining_column = 0; /* &id */
3195         size_t for_column = 2; /* &Value */
3196         size_t row, presence_index = 0;
3197         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct ResetResponseIEs, id));
3198
3199         for(row=0; row < itable->rows_count; row++) {
3200             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3201             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3202
3203             if(type_cell->cell_kind == aioc__undefined)
3204                 continue;
3205
3206             presence_index++;
3207             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3208                 result.type_descriptor = type_cell->type_descriptor;
3209                 result.presence_index = presence_index;
3210                 break;
3211             }
3212         }
3213
3214         return result;
3215 }
3216
3217 static int
3218 memb_value_constraint_85(const asn_TYPE_descriptor_t *td, const void *sptr,
3219                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3220
3221         if(!sptr) {
3222                 ASN__CTFAIL(app_key, td, sptr,
3223                         "%s: value not given (%s:%d)",
3224                         td->name, __FILE__, __LINE__);
3225                 return -1;
3226         }
3227
3228
3229         if(1 /* No applicable constraints whatsoever */) {
3230                 /* Nothing is here. See below */
3231         }
3232
3233         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3234 }
3235
3236 static int
3237 memb_id_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3238                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3239         long value;
3240
3241         if(!sptr) {
3242                 ASN__CTFAIL(app_key, td, sptr,
3243                         "%s: value not given (%s:%d)",
3244                         td->name, __FILE__, __LINE__);
3245                 return -1;
3246         }
3247
3248         value = *(const long *)sptr;
3249
3250         if((value >= 0 && value <= 65535)) {
3251                 /* Constraint check succeeded */
3252                 return 0;
3253         } else {
3254                 ASN__CTFAIL(app_key, td, sptr,
3255                         "%s: constraint failed (%s:%d)",
3256                         td->name, __FILE__, __LINE__);
3257                 return -1;
3258         }
3259 }
3260
3261 static asn_type_selector_result_t
3262 select_RICserviceUpdate_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3263         asn_type_selector_result_t result = {0, 0};
3264         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdate_IEs_1;
3265         size_t constraining_column = 0; /* &id */
3266         size_t for_column = 1; /* &criticality */
3267         size_t row, presence_index = 0;
3268         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdate_IEs, id));
3269
3270         for(row=0; row < itable->rows_count; row++) {
3271             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3272             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3273
3274             if(type_cell->cell_kind == aioc__undefined)
3275                 continue;
3276
3277             presence_index++;
3278             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3279                 result.type_descriptor = type_cell->type_descriptor;
3280                 result.presence_index = presence_index;
3281                 break;
3282             }
3283         }
3284
3285         return result;
3286 }
3287
3288 static int
3289 memb_criticality_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3290                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3291
3292         if(!sptr) {
3293                 ASN__CTFAIL(app_key, td, sptr,
3294                         "%s: value not given (%s:%d)",
3295                         td->name, __FILE__, __LINE__);
3296                 return -1;
3297         }
3298
3299
3300         if(1 /* No applicable constraints whatsoever */) {
3301                 /* Nothing is here. See below */
3302         }
3303
3304         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3305 }
3306
3307 static asn_type_selector_result_t
3308 select_RICserviceUpdate_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3309         asn_type_selector_result_t result = {0, 0};
3310         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdate_IEs_1;
3311         size_t constraining_column = 0; /* &id */
3312         size_t for_column = 2; /* &Value */
3313         size_t row, presence_index = 0;
3314         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdate_IEs, id));
3315
3316         static const int indexToPresent[] = { RICserviceUpdate_IEs__value_PR_NOTHING,
3317                                           RICserviceUpdate_IEs__value_PR_RANfunctions_List,
3318                                           RICserviceUpdate_IEs__value_PR_RANfunctions_List,
3319                                           RICserviceUpdate_IEs__value_PR_RANfunctionsID_List
3320         };
3321
3322         for(row=0; row < itable->rows_count; row++) {
3323             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3324             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3325
3326             if(type_cell->cell_kind == aioc__undefined)
3327                 continue;
3328
3329             presence_index++;
3330             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3331                 result.type_descriptor = type_cell->type_descriptor;
3332                 result.presence_index = indexToPresent[presence_index];
3333                 break;
3334             }
3335         }
3336
3337         return result;
3338 }
3339
3340 static int
3341 memb_value_constraint_89(const asn_TYPE_descriptor_t *td, const void *sptr,
3342                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3343
3344         if(!sptr) {
3345                 ASN__CTFAIL(app_key, td, sptr,
3346                         "%s: value not given (%s:%d)",
3347                         td->name, __FILE__, __LINE__);
3348                 return -1;
3349         }
3350
3351
3352         if(1 /* No applicable constraints whatsoever */) {
3353                 /* Nothing is here. See below */
3354         }
3355
3356         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3357 }
3358
3359 static int
3360 memb_id_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3361                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3362         long value;
3363
3364         if(!sptr) {
3365                 ASN__CTFAIL(app_key, td, sptr,
3366                         "%s: value not given (%s:%d)",
3367                         td->name, __FILE__, __LINE__);
3368                 return -1;
3369         }
3370
3371         value = *(const long *)sptr;
3372
3373         if((value >= 0 && value <= 65535)) {
3374                 /* Constraint check succeeded */
3375                 return 0;
3376         } else {
3377                 ASN__CTFAIL(app_key, td, sptr,
3378                         "%s: constraint failed (%s:%d)",
3379                         td->name, __FILE__, __LINE__);
3380                 return -1;
3381         }
3382 }
3383
3384 static asn_type_selector_result_t
3385 select_RICserviceUpdateAcknowledge_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3386         asn_type_selector_result_t result = {0, 0};
3387         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateAcknowledge_IEs_1;
3388         size_t constraining_column = 0; /* &id */
3389         size_t for_column = 1; /* &criticality */
3390         size_t row, presence_index = 0;
3391         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateAcknowledge_IEs, id));
3392
3393         for(row=0; row < itable->rows_count; row++) {
3394             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3395             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3396
3397             if(type_cell->cell_kind == aioc__undefined)
3398                 continue;
3399
3400             presence_index++;
3401             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3402                 result.type_descriptor = type_cell->type_descriptor;
3403                 result.presence_index = presence_index;
3404                 break;
3405             }
3406         }
3407
3408         return result;
3409 }
3410
3411 static int
3412 memb_criticality_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3413                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3414
3415         if(!sptr) {
3416                 ASN__CTFAIL(app_key, td, sptr,
3417                         "%s: value not given (%s:%d)",
3418                         td->name, __FILE__, __LINE__);
3419                 return -1;
3420         }
3421
3422
3423         if(1 /* No applicable constraints whatsoever */) {
3424                 /* Nothing is here. See below */
3425         }
3426
3427         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3428 }
3429
3430 static asn_type_selector_result_t
3431 select_RICserviceUpdateAcknowledge_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3432         asn_type_selector_result_t result = {0, 0};
3433         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateAcknowledge_IEs_1;
3434         size_t constraining_column = 0; /* &id */
3435         size_t for_column = 2; /* &Value */
3436         size_t row, presence_index = 0;
3437         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateAcknowledge_IEs, id));
3438
3439         for(row=0; row < itable->rows_count; row++) {
3440             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3441             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3442
3443             if(type_cell->cell_kind == aioc__undefined)
3444                 continue;
3445
3446             presence_index++;
3447             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3448                 result.type_descriptor = type_cell->type_descriptor;
3449                 result.presence_index = presence_index;
3450                 break;
3451             }
3452         }
3453
3454         return result;
3455 }
3456
3457 static int
3458 memb_value_constraint_93(const asn_TYPE_descriptor_t *td, const void *sptr,
3459                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3460
3461         if(!sptr) {
3462                 ASN__CTFAIL(app_key, td, sptr,
3463                         "%s: value not given (%s:%d)",
3464                         td->name, __FILE__, __LINE__);
3465                 return -1;
3466         }
3467
3468
3469         if(1 /* No applicable constraints whatsoever */) {
3470                 /* Nothing is here. See below */
3471         }
3472
3473         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3474 }
3475
3476 static int
3477 memb_id_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3478                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3479         long value;
3480
3481         if(!sptr) {
3482                 ASN__CTFAIL(app_key, td, sptr,
3483                         "%s: value not given (%s:%d)",
3484                         td->name, __FILE__, __LINE__);
3485                 return -1;
3486         }
3487
3488         value = *(const long *)sptr;
3489
3490         if((value >= 0 && value <= 65535)) {
3491                 /* Constraint check succeeded */
3492                 return 0;
3493         } else {
3494                 ASN__CTFAIL(app_key, td, sptr,
3495                         "%s: constraint failed (%s:%d)",
3496                         td->name, __FILE__, __LINE__);
3497                 return -1;
3498         }
3499 }
3500
3501 static asn_type_selector_result_t
3502 select_RICserviceUpdateFailure_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3503         asn_type_selector_result_t result = {0, 0};
3504         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateFailure_IEs_1;
3505         size_t constraining_column = 0; /* &id */
3506         size_t for_column = 1; /* &criticality */
3507         size_t row, presence_index = 0;
3508         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateFailure_IEs, id));
3509
3510         for(row=0; row < itable->rows_count; row++) {
3511             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3512             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3513
3514             if(type_cell->cell_kind == aioc__undefined)
3515                 continue;
3516
3517             presence_index++;
3518             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3519                 result.type_descriptor = type_cell->type_descriptor;
3520                 result.presence_index = presence_index;
3521                 break;
3522             }
3523         }
3524
3525         return result;
3526 }
3527
3528 static int
3529 memb_criticality_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3530                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3531
3532         if(!sptr) {
3533                 ASN__CTFAIL(app_key, td, sptr,
3534                         "%s: value not given (%s:%d)",
3535                         td->name, __FILE__, __LINE__);
3536                 return -1;
3537         }
3538
3539
3540         if(1 /* No applicable constraints whatsoever */) {
3541                 /* Nothing is here. See below */
3542         }
3543
3544         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3545 }
3546
3547 static asn_type_selector_result_t
3548 select_RICserviceUpdateFailure_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3549         asn_type_selector_result_t result = {0, 0};
3550         const asn_ioc_set_t *itable = asn_IOS_RICserviceUpdateFailure_IEs_1;
3551         size_t constraining_column = 0; /* &id */
3552         size_t for_column = 2; /* &Value */
3553         size_t row, presence_index = 0;
3554         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceUpdateFailure_IEs, id));
3555
3556         for(row=0; row < itable->rows_count; row++) {
3557             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3558             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3559
3560             if(type_cell->cell_kind == aioc__undefined)
3561                 continue;
3562
3563             presence_index++;
3564             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3565                 result.type_descriptor = type_cell->type_descriptor;
3566                 result.presence_index = presence_index;
3567                 break;
3568             }
3569         }
3570
3571         return result;
3572 }
3573
3574 static int
3575 memb_value_constraint_97(const asn_TYPE_descriptor_t *td, const void *sptr,
3576                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3577
3578         if(!sptr) {
3579                 ASN__CTFAIL(app_key, td, sptr,
3580                         "%s: value not given (%s:%d)",
3581                         td->name, __FILE__, __LINE__);
3582                 return -1;
3583         }
3584
3585
3586         if(1 /* No applicable constraints whatsoever */) {
3587                 /* Nothing is here. See below */
3588         }
3589
3590         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3591 }
3592
3593 static int
3594 memb_id_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3595                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3596         long value;
3597
3598         if(!sptr) {
3599                 ASN__CTFAIL(app_key, td, sptr,
3600                         "%s: value not given (%s:%d)",
3601                         td->name, __FILE__, __LINE__);
3602                 return -1;
3603         }
3604
3605         value = *(const long *)sptr;
3606
3607         if((value >= 0 && value <= 65535)) {
3608                 /* Constraint check succeeded */
3609                 return 0;
3610         } else {
3611                 ASN__CTFAIL(app_key, td, sptr,
3612                         "%s: constraint failed (%s:%d)",
3613                         td->name, __FILE__, __LINE__);
3614                 return -1;
3615         }
3616 }
3617
3618 static asn_type_selector_result_t
3619 select_RICserviceQuery_IEs_criticality_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3620         asn_type_selector_result_t result = {0, 0};
3621         const asn_ioc_set_t *itable = asn_IOS_RICserviceQuery_IEs_1;
3622         size_t constraining_column = 0; /* &id */
3623         size_t for_column = 1; /* &criticality */
3624         size_t row, presence_index = 0;
3625         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceQuery_IEs, id));
3626
3627         for(row=0; row < itable->rows_count; row++) {
3628             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3629             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3630
3631             if(type_cell->cell_kind == aioc__undefined)
3632                 continue;
3633
3634             presence_index++;
3635             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3636                 result.type_descriptor = type_cell->type_descriptor;
3637                 result.presence_index = presence_index;
3638                 break;
3639             }
3640         }
3641
3642         return result;
3643 }
3644
3645 static int
3646 memb_criticality_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3647                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3648
3649         if(!sptr) {
3650                 ASN__CTFAIL(app_key, td, sptr,
3651                         "%s: value not given (%s:%d)",
3652                         td->name, __FILE__, __LINE__);
3653                 return -1;
3654         }
3655
3656
3657         if(1 /* No applicable constraints whatsoever */) {
3658                 /* Nothing is here. See below */
3659         }
3660
3661         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3662 }
3663
3664 static asn_type_selector_result_t
3665 select_RICserviceQuery_IEs_value_type(const asn_TYPE_descriptor_t *parent_type, const void *parent_sptr) {
3666         asn_type_selector_result_t result = {0, 0};
3667         const asn_ioc_set_t *itable = asn_IOS_RICserviceQuery_IEs_1;
3668         size_t constraining_column = 0; /* &id */
3669         size_t for_column = 2; /* &Value */
3670         size_t row, presence_index = 0;
3671         const long *constraining_value = (const long *)((const char *)parent_sptr + offsetof(struct RICserviceQuery_IEs, id));
3672
3673         for(row=0; row < itable->rows_count; row++) {
3674             const asn_ioc_cell_t *constraining_cell = &itable->rows[row * itable->columns_count + constraining_column];
3675             const asn_ioc_cell_t *type_cell = &itable->rows[row * itable->columns_count + for_column];
3676
3677             if(type_cell->cell_kind == aioc__undefined)
3678                 continue;
3679
3680             presence_index++;
3681             if(constraining_cell->type_descriptor->op->compare_struct(constraining_cell->type_descriptor, constraining_value, constraining_cell->value_sptr) == 0) {
3682                 result.type_descriptor = type_cell->type_descriptor;
3683                 result.presence_index = presence_index;
3684                 break;
3685             }
3686         }
3687
3688         return result;
3689 }
3690
3691 static int
3692 memb_value_constraint_101(const asn_TYPE_descriptor_t *td, const void *sptr,
3693                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
3694
3695         if(!sptr) {
3696                 ASN__CTFAIL(app_key, td, sptr,
3697                         "%s: value not given (%s:%d)",
3698                         td->name, __FILE__, __LINE__);
3699                 return -1;
3700         }
3701
3702
3703         if(1 /* No applicable constraints whatsoever */) {
3704                 /* Nothing is here. See below */
3705         }
3706
3707         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
3708 }
3709
3710 static asn_per_constraints_t asn_PER_memb_id_constr_2 CC_NOTUSED = {
3711         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3712         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3713         0, 0    /* No PER value map */
3714 };
3715 static asn_per_constraints_t asn_PER_memb_criticality_constr_3 CC_NOTUSED = {
3716         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3717         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3718         0, 0    /* No PER value map */
3719 };
3720 static asn_per_constraints_t asn_PER_memb_value_constr_4 CC_NOTUSED = {
3721         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3722         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3723         0, 0    /* No PER value map */
3724 };
3725 static asn_per_constraints_t asn_PER_memb_id_constr_6 CC_NOTUSED = {
3726         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3727         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3728         0, 0    /* No PER value map */
3729 };
3730 static asn_per_constraints_t asn_PER_memb_criticality_constr_7 CC_NOTUSED = {
3731         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3732         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3733         0, 0    /* No PER value map */
3734 };
3735 static asn_per_constraints_t asn_PER_memb_value_constr_8 CC_NOTUSED = {
3736         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3737         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3738         0, 0    /* No PER value map */
3739 };
3740 static asn_per_constraints_t asn_PER_memb_id_constr_10 CC_NOTUSED = {
3741         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3742         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3743         0, 0    /* No PER value map */
3744 };
3745 static asn_per_constraints_t asn_PER_memb_criticality_constr_11 CC_NOTUSED = {
3746         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3747         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3748         0, 0    /* No PER value map */
3749 };
3750 static asn_per_constraints_t asn_PER_memb_value_constr_12 CC_NOTUSED = {
3751         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3752         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3753         0, 0    /* No PER value map */
3754 };
3755 static asn_per_constraints_t asn_PER_memb_id_constr_14 CC_NOTUSED = {
3756         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3757         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3758         0, 0    /* No PER value map */
3759 };
3760 static asn_per_constraints_t asn_PER_memb_criticality_constr_15 CC_NOTUSED = {
3761         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3762         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3763         0, 0    /* No PER value map */
3764 };
3765 static asn_per_constraints_t asn_PER_memb_value_constr_16 CC_NOTUSED = {
3766         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3767         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3768         0, 0    /* No PER value map */
3769 };
3770 static asn_per_constraints_t asn_PER_memb_id_constr_18 CC_NOTUSED = {
3771         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3772         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3773         0, 0    /* No PER value map */
3774 };
3775 static asn_per_constraints_t asn_PER_memb_criticality_constr_19 CC_NOTUSED = {
3776         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3777         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3778         0, 0    /* No PER value map */
3779 };
3780 static asn_per_constraints_t asn_PER_memb_value_constr_20 CC_NOTUSED = {
3781         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3782         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3783         0, 0    /* No PER value map */
3784 };
3785 static asn_per_constraints_t asn_PER_memb_id_constr_22 CC_NOTUSED = {
3786         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3787         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3788         0, 0    /* No PER value map */
3789 };
3790 static asn_per_constraints_t asn_PER_memb_criticality_constr_23 CC_NOTUSED = {
3791         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3792         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3793         0, 0    /* No PER value map */
3794 };
3795 static asn_per_constraints_t asn_PER_memb_value_constr_24 CC_NOTUSED = {
3796         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3797         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3798         0, 0    /* No PER value map */
3799 };
3800 static asn_per_constraints_t asn_PER_memb_id_constr_26 CC_NOTUSED = {
3801         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3802         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3803         0, 0    /* No PER value map */
3804 };
3805 static asn_per_constraints_t asn_PER_memb_criticality_constr_27 CC_NOTUSED = {
3806         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3807         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3808         0, 0    /* No PER value map */
3809 };
3810 static asn_per_constraints_t asn_PER_memb_value_constr_28 CC_NOTUSED = {
3811         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3812         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3813         0, 0    /* No PER value map */
3814 };
3815 static asn_per_constraints_t asn_PER_memb_id_constr_30 CC_NOTUSED = {
3816         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3817         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3818         0, 0    /* No PER value map */
3819 };
3820 static asn_per_constraints_t asn_PER_memb_criticality_constr_31 CC_NOTUSED = {
3821         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3822         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3823         0, 0    /* No PER value map */
3824 };
3825 static asn_per_constraints_t asn_PER_memb_value_constr_32 CC_NOTUSED = {
3826         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3827         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3828         0, 0    /* No PER value map */
3829 };
3830 static asn_per_constraints_t asn_PER_memb_id_constr_34 CC_NOTUSED = {
3831         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3832         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3833         0, 0    /* No PER value map */
3834 };
3835 static asn_per_constraints_t asn_PER_memb_criticality_constr_35 CC_NOTUSED = {
3836         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3837         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3838         0, 0    /* No PER value map */
3839 };
3840 static asn_per_constraints_t asn_PER_memb_value_constr_36 CC_NOTUSED = {
3841         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3842         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3843         0, 0    /* No PER value map */
3844 };
3845 static asn_per_constraints_t asn_PER_memb_id_constr_38 CC_NOTUSED = {
3846         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3847         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3848         0, 0    /* No PER value map */
3849 };
3850 static asn_per_constraints_t asn_PER_memb_criticality_constr_39 CC_NOTUSED = {
3851         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3852         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3853         0, 0    /* No PER value map */
3854 };
3855 static asn_per_constraints_t asn_PER_memb_value_constr_40 CC_NOTUSED = {
3856         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3857         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3858         0, 0    /* No PER value map */
3859 };
3860 static asn_per_constraints_t asn_PER_memb_id_constr_42 CC_NOTUSED = {
3861         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3862         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3863         0, 0    /* No PER value map */
3864 };
3865 static asn_per_constraints_t asn_PER_memb_criticality_constr_43 CC_NOTUSED = {
3866         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3867         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3868         0, 0    /* No PER value map */
3869 };
3870 static asn_per_constraints_t asn_PER_memb_value_constr_44 CC_NOTUSED = {
3871         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3872         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3873         0, 0    /* No PER value map */
3874 };
3875 static asn_per_constraints_t asn_PER_memb_id_constr_46 CC_NOTUSED = {
3876         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3877         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3878         0, 0    /* No PER value map */
3879 };
3880 static asn_per_constraints_t asn_PER_memb_criticality_constr_47 CC_NOTUSED = {
3881         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3882         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3883         0, 0    /* No PER value map */
3884 };
3885 static asn_per_constraints_t asn_PER_memb_value_constr_48 CC_NOTUSED = {
3886         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3887         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3888         0, 0    /* No PER value map */
3889 };
3890 static asn_per_constraints_t asn_PER_memb_id_constr_50 CC_NOTUSED = {
3891         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3892         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3893         0, 0    /* No PER value map */
3894 };
3895 static asn_per_constraints_t asn_PER_memb_criticality_constr_51 CC_NOTUSED = {
3896         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3897         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3898         0, 0    /* No PER value map */
3899 };
3900 static asn_per_constraints_t asn_PER_memb_value_constr_52 CC_NOTUSED = {
3901         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3902         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3903         0, 0    /* No PER value map */
3904 };
3905 static asn_per_constraints_t asn_PER_memb_id_constr_54 CC_NOTUSED = {
3906         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3907         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3908         0, 0    /* No PER value map */
3909 };
3910 static asn_per_constraints_t asn_PER_memb_criticality_constr_55 CC_NOTUSED = {
3911         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3912         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3913         0, 0    /* No PER value map */
3914 };
3915 static asn_per_constraints_t asn_PER_memb_value_constr_56 CC_NOTUSED = {
3916         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3917         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3918         0, 0    /* No PER value map */
3919 };
3920 static asn_per_constraints_t asn_PER_memb_id_constr_58 CC_NOTUSED = {
3921         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3922         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3923         0, 0    /* No PER value map */
3924 };
3925 static asn_per_constraints_t asn_PER_memb_criticality_constr_59 CC_NOTUSED = {
3926         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3927         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3928         0, 0    /* No PER value map */
3929 };
3930 static asn_per_constraints_t asn_PER_memb_value_constr_60 CC_NOTUSED = {
3931         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3932         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3933         0, 0    /* No PER value map */
3934 };
3935 static asn_per_constraints_t asn_PER_memb_id_constr_62 CC_NOTUSED = {
3936         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3937         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3938         0, 0    /* No PER value map */
3939 };
3940 static asn_per_constraints_t asn_PER_memb_criticality_constr_63 CC_NOTUSED = {
3941         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3942         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3943         0, 0    /* No PER value map */
3944 };
3945 static asn_per_constraints_t asn_PER_memb_value_constr_64 CC_NOTUSED = {
3946         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3947         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3948         0, 0    /* No PER value map */
3949 };
3950 static asn_per_constraints_t asn_PER_memb_id_constr_66 CC_NOTUSED = {
3951         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3952         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3953         0, 0    /* No PER value map */
3954 };
3955 static asn_per_constraints_t asn_PER_memb_criticality_constr_67 CC_NOTUSED = {
3956         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3957         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3958         0, 0    /* No PER value map */
3959 };
3960 static asn_per_constraints_t asn_PER_memb_value_constr_68 CC_NOTUSED = {
3961         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3962         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3963         0, 0    /* No PER value map */
3964 };
3965 static asn_per_constraints_t asn_PER_memb_id_constr_70 CC_NOTUSED = {
3966         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3967         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3968         0, 0    /* No PER value map */
3969 };
3970 static asn_per_constraints_t asn_PER_memb_criticality_constr_71 CC_NOTUSED = {
3971         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3972         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3973         0, 0    /* No PER value map */
3974 };
3975 static asn_per_constraints_t asn_PER_memb_value_constr_72 CC_NOTUSED = {
3976         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3977         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3978         0, 0    /* No PER value map */
3979 };
3980 static asn_per_constraints_t asn_PER_memb_id_constr_74 CC_NOTUSED = {
3981         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3982         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3983         0, 0    /* No PER value map */
3984 };
3985 static asn_per_constraints_t asn_PER_memb_criticality_constr_75 CC_NOTUSED = {
3986         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
3987         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3988         0, 0    /* No PER value map */
3989 };
3990 static asn_per_constraints_t asn_PER_memb_value_constr_76 CC_NOTUSED = {
3991         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3992         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3993         0, 0    /* No PER value map */
3994 };
3995 static asn_per_constraints_t asn_PER_memb_id_constr_78 CC_NOTUSED = {
3996         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
3997         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
3998         0, 0    /* No PER value map */
3999 };
4000 static asn_per_constraints_t asn_PER_memb_criticality_constr_79 CC_NOTUSED = {
4001         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4002         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4003         0, 0    /* No PER value map */
4004 };
4005 static asn_per_constraints_t asn_PER_memb_value_constr_80 CC_NOTUSED = {
4006         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4007         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4008         0, 0    /* No PER value map */
4009 };
4010 static asn_per_constraints_t asn_PER_memb_id_constr_82 CC_NOTUSED = {
4011         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4012         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4013         0, 0    /* No PER value map */
4014 };
4015 static asn_per_constraints_t asn_PER_memb_criticality_constr_83 CC_NOTUSED = {
4016         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4017         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4018         0, 0    /* No PER value map */
4019 };
4020 static asn_per_constraints_t asn_PER_memb_value_constr_84 CC_NOTUSED = {
4021         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4022         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4023         0, 0    /* No PER value map */
4024 };
4025 static asn_per_constraints_t asn_PER_memb_id_constr_86 CC_NOTUSED = {
4026         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4027         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4028         0, 0    /* No PER value map */
4029 };
4030 static asn_per_constraints_t asn_PER_memb_criticality_constr_87 CC_NOTUSED = {
4031         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4032         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4033         0, 0    /* No PER value map */
4034 };
4035 static asn_per_constraints_t asn_PER_memb_value_constr_88 CC_NOTUSED = {
4036         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4037         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4038         0, 0    /* No PER value map */
4039 };
4040 static asn_per_constraints_t asn_PER_memb_id_constr_90 CC_NOTUSED = {
4041         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4042         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4043         0, 0    /* No PER value map */
4044 };
4045 static asn_per_constraints_t asn_PER_memb_criticality_constr_91 CC_NOTUSED = {
4046         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4047         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4048         0, 0    /* No PER value map */
4049 };
4050 static asn_per_constraints_t asn_PER_memb_value_constr_92 CC_NOTUSED = {
4051         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4052         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4053         0, 0    /* No PER value map */
4054 };
4055 static asn_per_constraints_t asn_PER_memb_id_constr_94 CC_NOTUSED = {
4056         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4057         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4058         0, 0    /* No PER value map */
4059 };
4060 static asn_per_constraints_t asn_PER_memb_criticality_constr_95 CC_NOTUSED = {
4061         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4062         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4063         0, 0    /* No PER value map */
4064 };
4065 static asn_per_constraints_t asn_PER_memb_value_constr_96 CC_NOTUSED = {
4066         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4067         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4068         0, 0    /* No PER value map */
4069 };
4070 static asn_per_constraints_t asn_PER_memb_id_constr_98 CC_NOTUSED = {
4071         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4072         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4073         0, 0    /* No PER value map */
4074 };
4075 static asn_per_constraints_t asn_PER_memb_criticality_constr_99 CC_NOTUSED = {
4076         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4077         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4078         0, 0    /* No PER value map */
4079 };
4080 static asn_per_constraints_t asn_PER_memb_value_constr_100 CC_NOTUSED = {
4081         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4082         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4083         0, 0    /* No PER value map */
4084 };
4085 static asn_per_constraints_t asn_PER_memb_id_constr_102 CC_NOTUSED = {
4086         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
4087         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4088         0, 0    /* No PER value map */
4089 };
4090 static asn_per_constraints_t asn_PER_memb_criticality_constr_103 CC_NOTUSED = {
4091         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
4092         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4093         0, 0    /* No PER value map */
4094 };
4095 static asn_per_constraints_t asn_PER_memb_value_constr_104 CC_NOTUSED = {
4096         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4097         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
4098         0, 0    /* No PER value map */
4099 };
4100 static asn_TYPE_member_t asn_MBR_value_4[] = {
4101         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs__value, choice.RICaction_ToBeSetup_Item),
4102                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4103                 0,
4104                 &asn_DEF_RICaction_ToBeSetup_Item,
4105                 0,
4106                 { 0, 0, 0 },
4107                 0, 0, /* No default value */
4108                 "RICaction-ToBeSetup-Item"
4109                 },
4110 };
4111 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_4[] = {
4112     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-ToBeSetup-Item */
4113 };
4114 static asn_CHOICE_specifics_t asn_SPC_value_specs_4 = {
4115         sizeof(struct RICaction_ToBeSetup_ItemIEs__value),
4116         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, _asn_ctx),
4117         offsetof(struct RICaction_ToBeSetup_ItemIEs__value, present),
4118         sizeof(((struct RICaction_ToBeSetup_ItemIEs__value *)0)->present),
4119         asn_MAP_value_tag2el_4,
4120         1,      /* Count of tags in the map */
4121         0, 0,
4122         -1      /* Extensions start */
4123 };
4124 static /* Use -fall-defs-global to expose */
4125 asn_TYPE_descriptor_t asn_DEF_value_4 = {
4126         "value",
4127         "value",
4128         &asn_OP_OPEN_TYPE,
4129         0,      /* No effective tags (pointer) */
4130         0,      /* No effective tags (count) */
4131         0,      /* No tags (pointer) */
4132         0,      /* No tags (count) */
4133         { 0, 0, OPEN_TYPE_constraint },
4134         asn_MBR_value_4,
4135         1,      /* Elements count */
4136         &asn_SPC_value_specs_4  /* Additional specs */
4137 };
4138
4139 asn_TYPE_member_t asn_MBR_RICaction_ToBeSetup_ItemIEs_1[] = {
4140         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, id),
4141                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4142                 -1,     /* IMPLICIT tag at current level */
4143                 &asn_DEF_ProtocolIE_ID,
4144                 0,
4145                 { 0, &asn_PER_memb_id_constr_2,  memb_id_constraint_1 },
4146                 0, 0, /* No default value */
4147                 "id"
4148                 },
4149         { ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, criticality),
4150                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4151                 -1,     /* IMPLICIT tag at current level */
4152                 &asn_DEF_Criticality,
4153                 select_RICaction_ToBeSetup_ItemIEs_criticality_type,
4154                 { 0, &asn_PER_memb_criticality_constr_3,  memb_criticality_constraint_1 },
4155                 0, 0, /* No default value */
4156                 "criticality"
4157                 },
4158         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_ToBeSetup_ItemIEs, value),
4159                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4160                 +1,     /* EXPLICIT tag at current level */
4161                 &asn_DEF_value_4,
4162                 select_RICaction_ToBeSetup_ItemIEs_value_type,
4163                 { 0, &asn_PER_memb_value_constr_4,  memb_value_constraint_1 },
4164                 0, 0, /* No default value */
4165                 "value"
4166                 },
4167 };
4168 static const ber_tlv_tag_t asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[] = {
4169         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4170 };
4171 static const asn_TYPE_tag2member_t asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1[] = {
4172     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4173     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4174     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4175 };
4176 asn_SEQUENCE_specifics_t asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1 = {
4177         sizeof(struct RICaction_ToBeSetup_ItemIEs),
4178         offsetof(struct RICaction_ToBeSetup_ItemIEs, _asn_ctx),
4179         asn_MAP_RICaction_ToBeSetup_ItemIEs_tag2el_1,
4180         3,      /* Count of tags in the map */
4181         0, 0, 0,        /* Optional elements (not needed) */
4182         -1,     /* First extension addition */
4183 };
4184 asn_TYPE_descriptor_t asn_DEF_RICaction_ToBeSetup_ItemIEs = {
4185         "RICaction-ToBeSetup-ItemIEs",
4186         "RICaction-ToBeSetup-ItemIEs",
4187         &asn_OP_SEQUENCE,
4188         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,
4189         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
4190                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
4191         asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1,     /* Same as above */
4192         sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1)
4193                 /sizeof(asn_DEF_RICaction_ToBeSetup_ItemIEs_tags_1[0]), /* 1 */
4194         { 0, 0, SEQUENCE_constraint },
4195         asn_MBR_RICaction_ToBeSetup_ItemIEs_1,
4196         3,      /* Elements count */
4197         &asn_SPC_RICaction_ToBeSetup_ItemIEs_specs_1    /* Additional specs */
4198 };
4199
4200 static asn_TYPE_member_t asn_MBR_value_8[] = {
4201         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs__value, choice.RICaction_Admitted_Item),
4202                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4203                 0,
4204                 &asn_DEF_RICaction_Admitted_Item,
4205                 0,
4206                 { 0, 0, 0 },
4207                 0, 0, /* No default value */
4208                 "RICaction-Admitted-Item"
4209                 },
4210 };
4211 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_8[] = {
4212     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-Admitted-Item */
4213 };
4214 static asn_CHOICE_specifics_t asn_SPC_value_specs_8 = {
4215         sizeof(struct RICaction_Admitted_ItemIEs__value),
4216         offsetof(struct RICaction_Admitted_ItemIEs__value, _asn_ctx),
4217         offsetof(struct RICaction_Admitted_ItemIEs__value, present),
4218         sizeof(((struct RICaction_Admitted_ItemIEs__value *)0)->present),
4219         asn_MAP_value_tag2el_8,
4220         1,      /* Count of tags in the map */
4221         0, 0,
4222         -1      /* Extensions start */
4223 };
4224 static /* Use -fall-defs-global to expose */
4225 asn_TYPE_descriptor_t asn_DEF_value_8 = {
4226         "value",
4227         "value",
4228         &asn_OP_OPEN_TYPE,
4229         0,      /* No effective tags (pointer) */
4230         0,      /* No effective tags (count) */
4231         0,      /* No tags (pointer) */
4232         0,      /* No tags (count) */
4233         { 0, 0, OPEN_TYPE_constraint },
4234         asn_MBR_value_8,
4235         1,      /* Elements count */
4236         &asn_SPC_value_specs_8  /* Additional specs */
4237 };
4238
4239 asn_TYPE_member_t asn_MBR_RICaction_Admitted_ItemIEs_5[] = {
4240         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, id),
4241                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4242                 -1,     /* IMPLICIT tag at current level */
4243                 &asn_DEF_ProtocolIE_ID,
4244                 0,
4245                 { 0, &asn_PER_memb_id_constr_6,  memb_id_constraint_5 },
4246                 0, 0, /* No default value */
4247                 "id"
4248                 },
4249         { ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, criticality),
4250                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4251                 -1,     /* IMPLICIT tag at current level */
4252                 &asn_DEF_Criticality,
4253                 select_RICaction_Admitted_ItemIEs_criticality_type,
4254                 { 0, &asn_PER_memb_criticality_constr_7,  memb_criticality_constraint_5 },
4255                 0, 0, /* No default value */
4256                 "criticality"
4257                 },
4258         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_Admitted_ItemIEs, value),
4259                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4260                 +1,     /* EXPLICIT tag at current level */
4261                 &asn_DEF_value_8,
4262                 select_RICaction_Admitted_ItemIEs_value_type,
4263                 { 0, &asn_PER_memb_value_constr_8,  memb_value_constraint_5 },
4264                 0, 0, /* No default value */
4265                 "value"
4266                 },
4267 };
4268 static const ber_tlv_tag_t asn_DEF_RICaction_Admitted_ItemIEs_tags_5[] = {
4269         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4270 };
4271 static const asn_TYPE_tag2member_t asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5[] = {
4272     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4273     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4274     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4275 };
4276 asn_SEQUENCE_specifics_t asn_SPC_RICaction_Admitted_ItemIEs_specs_5 = {
4277         sizeof(struct RICaction_Admitted_ItemIEs),
4278         offsetof(struct RICaction_Admitted_ItemIEs, _asn_ctx),
4279         asn_MAP_RICaction_Admitted_ItemIEs_tag2el_5,
4280         3,      /* Count of tags in the map */
4281         0, 0, 0,        /* Optional elements (not needed) */
4282         -1,     /* First extension addition */
4283 };
4284 asn_TYPE_descriptor_t asn_DEF_RICaction_Admitted_ItemIEs = {
4285         "RICaction-Admitted-ItemIEs",
4286         "RICaction-Admitted-ItemIEs",
4287         &asn_OP_SEQUENCE,
4288         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,
4289         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
4290                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
4291         asn_DEF_RICaction_Admitted_ItemIEs_tags_5,      /* Same as above */
4292         sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5)
4293                 /sizeof(asn_DEF_RICaction_Admitted_ItemIEs_tags_5[0]), /* 1 */
4294         { 0, 0, SEQUENCE_constraint },
4295         asn_MBR_RICaction_Admitted_ItemIEs_5,
4296         3,      /* Elements count */
4297         &asn_SPC_RICaction_Admitted_ItemIEs_specs_5     /* Additional specs */
4298 };
4299
4300 static asn_TYPE_member_t asn_MBR_value_12[] = {
4301         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs__value, choice.RICaction_NotAdmitted_Item),
4302                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4303                 0,
4304                 &asn_DEF_RICaction_NotAdmitted_Item,
4305                 0,
4306                 { 0, 0, 0 },
4307                 0, 0, /* No default value */
4308                 "RICaction-NotAdmitted-Item"
4309                 },
4310 };
4311 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_12[] = {
4312     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICaction-NotAdmitted-Item */
4313 };
4314 static asn_CHOICE_specifics_t asn_SPC_value_specs_12 = {
4315         sizeof(struct RICaction_NotAdmitted_ItemIEs__value),
4316         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, _asn_ctx),
4317         offsetof(struct RICaction_NotAdmitted_ItemIEs__value, present),
4318         sizeof(((struct RICaction_NotAdmitted_ItemIEs__value *)0)->present),
4319         asn_MAP_value_tag2el_12,
4320         1,      /* Count of tags in the map */
4321         0, 0,
4322         -1      /* Extensions start */
4323 };
4324 static /* Use -fall-defs-global to expose */
4325 asn_TYPE_descriptor_t asn_DEF_value_12 = {
4326         "value",
4327         "value",
4328         &asn_OP_OPEN_TYPE,
4329         0,      /* No effective tags (pointer) */
4330         0,      /* No effective tags (count) */
4331         0,      /* No tags (pointer) */
4332         0,      /* No tags (count) */
4333         { 0, 0, OPEN_TYPE_constraint },
4334         asn_MBR_value_12,
4335         1,      /* Elements count */
4336         &asn_SPC_value_specs_12 /* Additional specs */
4337 };
4338
4339 asn_TYPE_member_t asn_MBR_RICaction_NotAdmitted_ItemIEs_9[] = {
4340         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, id),
4341                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4342                 -1,     /* IMPLICIT tag at current level */
4343                 &asn_DEF_ProtocolIE_ID,
4344                 0,
4345                 { 0, &asn_PER_memb_id_constr_10,  memb_id_constraint_9 },
4346                 0, 0, /* No default value */
4347                 "id"
4348                 },
4349         { ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, criticality),
4350                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4351                 -1,     /* IMPLICIT tag at current level */
4352                 &asn_DEF_Criticality,
4353                 select_RICaction_NotAdmitted_ItemIEs_criticality_type,
4354                 { 0, &asn_PER_memb_criticality_constr_11,  memb_criticality_constraint_9 },
4355                 0, 0, /* No default value */
4356                 "criticality"
4357                 },
4358         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICaction_NotAdmitted_ItemIEs, value),
4359                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4360                 +1,     /* EXPLICIT tag at current level */
4361                 &asn_DEF_value_12,
4362                 select_RICaction_NotAdmitted_ItemIEs_value_type,
4363                 { 0, &asn_PER_memb_value_constr_12,  memb_value_constraint_9 },
4364                 0, 0, /* No default value */
4365                 "value"
4366                 },
4367 };
4368 static const ber_tlv_tag_t asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[] = {
4369         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4370 };
4371 static const asn_TYPE_tag2member_t asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9[] = {
4372     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4373     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4374     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4375 };
4376 asn_SEQUENCE_specifics_t asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9 = {
4377         sizeof(struct RICaction_NotAdmitted_ItemIEs),
4378         offsetof(struct RICaction_NotAdmitted_ItemIEs, _asn_ctx),
4379         asn_MAP_RICaction_NotAdmitted_ItemIEs_tag2el_9,
4380         3,      /* Count of tags in the map */
4381         0, 0, 0,        /* Optional elements (not needed) */
4382         -1,     /* First extension addition */
4383 };
4384 asn_TYPE_descriptor_t asn_DEF_RICaction_NotAdmitted_ItemIEs = {
4385         "RICaction-NotAdmitted-ItemIEs",
4386         "RICaction-NotAdmitted-ItemIEs",
4387         &asn_OP_SEQUENCE,
4388         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,
4389         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
4390                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
4391         asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9,   /* Same as above */
4392         sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9)
4393                 /sizeof(asn_DEF_RICaction_NotAdmitted_ItemIEs_tags_9[0]), /* 1 */
4394         { 0, 0, SEQUENCE_constraint },
4395         asn_MBR_RICaction_NotAdmitted_ItemIEs_9,
4396         3,      /* Elements count */
4397         &asn_SPC_RICaction_NotAdmitted_ItemIEs_specs_9  /* Additional specs */
4398 };
4399
4400 static asn_TYPE_member_t asn_MBR_value_16[] = {
4401         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs__value, choice.RANfunction_Item),
4402                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4403                 0,
4404                 &asn_DEF_RANfunction_Item,
4405                 0,
4406                 { 0, 0, 0 },
4407                 0, 0, /* No default value */
4408                 "RANfunction-Item"
4409                 },
4410 };
4411 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_16[] = {
4412     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunction-Item */
4413 };
4414 static asn_CHOICE_specifics_t asn_SPC_value_specs_16 = {
4415         sizeof(struct RANfunction_ItemIEs__value),
4416         offsetof(struct RANfunction_ItemIEs__value, _asn_ctx),
4417         offsetof(struct RANfunction_ItemIEs__value, present),
4418         sizeof(((struct RANfunction_ItemIEs__value *)0)->present),
4419         asn_MAP_value_tag2el_16,
4420         1,      /* Count of tags in the map */
4421         0, 0,
4422         -1      /* Extensions start */
4423 };
4424 static /* Use -fall-defs-global to expose */
4425 asn_TYPE_descriptor_t asn_DEF_value_16 = {
4426         "value",
4427         "value",
4428         &asn_OP_OPEN_TYPE,
4429         0,      /* No effective tags (pointer) */
4430         0,      /* No effective tags (count) */
4431         0,      /* No tags (pointer) */
4432         0,      /* No tags (count) */
4433         { 0, 0, OPEN_TYPE_constraint },
4434         asn_MBR_value_16,
4435         1,      /* Elements count */
4436         &asn_SPC_value_specs_16 /* Additional specs */
4437 };
4438
4439 asn_TYPE_member_t asn_MBR_RANfunction_ItemIEs_13[] = {
4440         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, id),
4441                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4442                 -1,     /* IMPLICIT tag at current level */
4443                 &asn_DEF_ProtocolIE_ID,
4444                 0,
4445                 { 0, &asn_PER_memb_id_constr_14,  memb_id_constraint_13 },
4446                 0, 0, /* No default value */
4447                 "id"
4448                 },
4449         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, criticality),
4450                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4451                 -1,     /* IMPLICIT tag at current level */
4452                 &asn_DEF_Criticality,
4453                 select_RANfunction_ItemIEs_criticality_type,
4454                 { 0, &asn_PER_memb_criticality_constr_15,  memb_criticality_constraint_13 },
4455                 0, 0, /* No default value */
4456                 "criticality"
4457                 },
4458         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunction_ItemIEs, value),
4459                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4460                 +1,     /* EXPLICIT tag at current level */
4461                 &asn_DEF_value_16,
4462                 select_RANfunction_ItemIEs_value_type,
4463                 { 0, &asn_PER_memb_value_constr_16,  memb_value_constraint_13 },
4464                 0, 0, /* No default value */
4465                 "value"
4466                 },
4467 };
4468 static const ber_tlv_tag_t asn_DEF_RANfunction_ItemIEs_tags_13[] = {
4469         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4470 };
4471 static const asn_TYPE_tag2member_t asn_MAP_RANfunction_ItemIEs_tag2el_13[] = {
4472     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4473     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4474     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4475 };
4476 asn_SEQUENCE_specifics_t asn_SPC_RANfunction_ItemIEs_specs_13 = {
4477         sizeof(struct RANfunction_ItemIEs),
4478         offsetof(struct RANfunction_ItemIEs, _asn_ctx),
4479         asn_MAP_RANfunction_ItemIEs_tag2el_13,
4480         3,      /* Count of tags in the map */
4481         0, 0, 0,        /* Optional elements (not needed) */
4482         -1,     /* First extension addition */
4483 };
4484 asn_TYPE_descriptor_t asn_DEF_RANfunction_ItemIEs = {
4485         "RANfunction-ItemIEs",
4486         "RANfunction-ItemIEs",
4487         &asn_OP_SEQUENCE,
4488         asn_DEF_RANfunction_ItemIEs_tags_13,
4489         sizeof(asn_DEF_RANfunction_ItemIEs_tags_13)
4490                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_13[0]), /* 1 */
4491         asn_DEF_RANfunction_ItemIEs_tags_13,    /* Same as above */
4492         sizeof(asn_DEF_RANfunction_ItemIEs_tags_13)
4493                 /sizeof(asn_DEF_RANfunction_ItemIEs_tags_13[0]), /* 1 */
4494         { 0, 0, SEQUENCE_constraint },
4495         asn_MBR_RANfunction_ItemIEs_13,
4496         3,      /* Elements count */
4497         &asn_SPC_RANfunction_ItemIEs_specs_13   /* Additional specs */
4498 };
4499
4500 static asn_TYPE_member_t asn_MBR_value_20[] = {
4501         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs__value, choice.RANfunctionID_Item),
4502                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4503                 0,
4504                 &asn_DEF_RANfunctionID_Item,
4505                 0,
4506                 { 0, 0, 0 },
4507                 0, 0, /* No default value */
4508                 "RANfunctionID-Item"
4509                 },
4510 };
4511 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_20[] = {
4512     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionID-Item */
4513 };
4514 static asn_CHOICE_specifics_t asn_SPC_value_specs_20 = {
4515         sizeof(struct RANfunctionID_ItemIEs__value),
4516         offsetof(struct RANfunctionID_ItemIEs__value, _asn_ctx),
4517         offsetof(struct RANfunctionID_ItemIEs__value, present),
4518         sizeof(((struct RANfunctionID_ItemIEs__value *)0)->present),
4519         asn_MAP_value_tag2el_20,
4520         1,      /* Count of tags in the map */
4521         0, 0,
4522         -1      /* Extensions start */
4523 };
4524 static /* Use -fall-defs-global to expose */
4525 asn_TYPE_descriptor_t asn_DEF_value_20 = {
4526         "value",
4527         "value",
4528         &asn_OP_OPEN_TYPE,
4529         0,      /* No effective tags (pointer) */
4530         0,      /* No effective tags (count) */
4531         0,      /* No tags (pointer) */
4532         0,      /* No tags (count) */
4533         { 0, 0, OPEN_TYPE_constraint },
4534         asn_MBR_value_20,
4535         1,      /* Elements count */
4536         &asn_SPC_value_specs_20 /* Additional specs */
4537 };
4538
4539 asn_TYPE_member_t asn_MBR_RANfunctionID_ItemIEs_17[] = {
4540         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, id),
4541                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4542                 -1,     /* IMPLICIT tag at current level */
4543                 &asn_DEF_ProtocolIE_ID,
4544                 0,
4545                 { 0, &asn_PER_memb_id_constr_18,  memb_id_constraint_17 },
4546                 0, 0, /* No default value */
4547                 "id"
4548                 },
4549         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, criticality),
4550                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4551                 -1,     /* IMPLICIT tag at current level */
4552                 &asn_DEF_Criticality,
4553                 select_RANfunctionID_ItemIEs_criticality_type,
4554                 { 0, &asn_PER_memb_criticality_constr_19,  memb_criticality_constraint_17 },
4555                 0, 0, /* No default value */
4556                 "criticality"
4557                 },
4558         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionID_ItemIEs, value),
4559                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4560                 +1,     /* EXPLICIT tag at current level */
4561                 &asn_DEF_value_20,
4562                 select_RANfunctionID_ItemIEs_value_type,
4563                 { 0, &asn_PER_memb_value_constr_20,  memb_value_constraint_17 },
4564                 0, 0, /* No default value */
4565                 "value"
4566                 },
4567 };
4568 static const ber_tlv_tag_t asn_DEF_RANfunctionID_ItemIEs_tags_17[] = {
4569         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4570 };
4571 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionID_ItemIEs_tag2el_17[] = {
4572     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4573     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4574     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4575 };
4576 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionID_ItemIEs_specs_17 = {
4577         sizeof(struct RANfunctionID_ItemIEs),
4578         offsetof(struct RANfunctionID_ItemIEs, _asn_ctx),
4579         asn_MAP_RANfunctionID_ItemIEs_tag2el_17,
4580         3,      /* Count of tags in the map */
4581         0, 0, 0,        /* Optional elements (not needed) */
4582         -1,     /* First extension addition */
4583 };
4584 asn_TYPE_descriptor_t asn_DEF_RANfunctionID_ItemIEs = {
4585         "RANfunctionID-ItemIEs",
4586         "RANfunctionID-ItemIEs",
4587         &asn_OP_SEQUENCE,
4588         asn_DEF_RANfunctionID_ItemIEs_tags_17,
4589         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17)
4590                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
4591         asn_DEF_RANfunctionID_ItemIEs_tags_17,  /* Same as above */
4592         sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17)
4593                 /sizeof(asn_DEF_RANfunctionID_ItemIEs_tags_17[0]), /* 1 */
4594         { 0, 0, SEQUENCE_constraint },
4595         asn_MBR_RANfunctionID_ItemIEs_17,
4596         3,      /* Elements count */
4597         &asn_SPC_RANfunctionID_ItemIEs_specs_17 /* Additional specs */
4598 };
4599
4600 static asn_TYPE_member_t asn_MBR_value_24[] = {
4601         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs__value, choice.RANfunctionIDcause_Item),
4602                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4603                 0,
4604                 &asn_DEF_RANfunctionIDcause_Item,
4605                 0,
4606                 { 0, 0, 0 },
4607                 0, 0, /* No default value */
4608                 "RANfunctionIDcause-Item"
4609                 },
4610 };
4611 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_24[] = {
4612     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionIDcause-Item */
4613 };
4614 static asn_CHOICE_specifics_t asn_SPC_value_specs_24 = {
4615         sizeof(struct RANfunctionIDcause_ItemIEs__value),
4616         offsetof(struct RANfunctionIDcause_ItemIEs__value, _asn_ctx),
4617         offsetof(struct RANfunctionIDcause_ItemIEs__value, present),
4618         sizeof(((struct RANfunctionIDcause_ItemIEs__value *)0)->present),
4619         asn_MAP_value_tag2el_24,
4620         1,      /* Count of tags in the map */
4621         0, 0,
4622         -1      /* Extensions start */
4623 };
4624 static /* Use -fall-defs-global to expose */
4625 asn_TYPE_descriptor_t asn_DEF_value_24 = {
4626         "value",
4627         "value",
4628         &asn_OP_OPEN_TYPE,
4629         0,      /* No effective tags (pointer) */
4630         0,      /* No effective tags (count) */
4631         0,      /* No tags (pointer) */
4632         0,      /* No tags (count) */
4633         { 0, 0, OPEN_TYPE_constraint },
4634         asn_MBR_value_24,
4635         1,      /* Elements count */
4636         &asn_SPC_value_specs_24 /* Additional specs */
4637 };
4638
4639 asn_TYPE_member_t asn_MBR_RANfunctionIDcause_ItemIEs_21[] = {
4640         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, id),
4641                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4642                 -1,     /* IMPLICIT tag at current level */
4643                 &asn_DEF_ProtocolIE_ID,
4644                 0,
4645                 { 0, &asn_PER_memb_id_constr_22,  memb_id_constraint_21 },
4646                 0, 0, /* No default value */
4647                 "id"
4648                 },
4649         { ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, criticality),
4650                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4651                 -1,     /* IMPLICIT tag at current level */
4652                 &asn_DEF_Criticality,
4653                 select_RANfunctionIDcause_ItemIEs_criticality_type,
4654                 { 0, &asn_PER_memb_criticality_constr_23,  memb_criticality_constraint_21 },
4655                 0, 0, /* No default value */
4656                 "criticality"
4657                 },
4658         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RANfunctionIDcause_ItemIEs, value),
4659                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4660                 +1,     /* EXPLICIT tag at current level */
4661                 &asn_DEF_value_24,
4662                 select_RANfunctionIDcause_ItemIEs_value_type,
4663                 { 0, &asn_PER_memb_value_constr_24,  memb_value_constraint_21 },
4664                 0, 0, /* No default value */
4665                 "value"
4666                 },
4667 };
4668 static const ber_tlv_tag_t asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[] = {
4669         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4670 };
4671 static const asn_TYPE_tag2member_t asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_21[] = {
4672     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4673     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4674     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4675 };
4676 asn_SEQUENCE_specifics_t asn_SPC_RANfunctionIDcause_ItemIEs_specs_21 = {
4677         sizeof(struct RANfunctionIDcause_ItemIEs),
4678         offsetof(struct RANfunctionIDcause_ItemIEs, _asn_ctx),
4679         asn_MAP_RANfunctionIDcause_ItemIEs_tag2el_21,
4680         3,      /* Count of tags in the map */
4681         0, 0, 0,        /* Optional elements (not needed) */
4682         -1,     /* First extension addition */
4683 };
4684 asn_TYPE_descriptor_t asn_DEF_RANfunctionIDcause_ItemIEs = {
4685         "RANfunctionIDcause-ItemIEs",
4686         "RANfunctionIDcause-ItemIEs",
4687         &asn_OP_SEQUENCE,
4688         asn_DEF_RANfunctionIDcause_ItemIEs_tags_21,
4689         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21)
4690                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
4691         asn_DEF_RANfunctionIDcause_ItemIEs_tags_21,     /* Same as above */
4692         sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21)
4693                 /sizeof(asn_DEF_RANfunctionIDcause_ItemIEs_tags_21[0]), /* 1 */
4694         { 0, 0, SEQUENCE_constraint },
4695         asn_MBR_RANfunctionIDcause_ItemIEs_21,
4696         3,      /* Elements count */
4697         &asn_SPC_RANfunctionIDcause_ItemIEs_specs_21    /* Additional specs */
4698 };
4699
4700 static asn_TYPE_member_t asn_MBR_value_28[] = {
4701         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICrequestID),
4702                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4703                 0,
4704                 &asn_DEF_RICrequestID,
4705                 0,
4706                 { 0, 0, 0 },
4707                 0, 0, /* No default value */
4708                 "RICrequestID"
4709                 },
4710         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RANfunctionID),
4711                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4712                 0,
4713                 &asn_DEF_RANfunctionID,
4714                 0,
4715                 { 0, 0, 0 },
4716                 0, 0, /* No default value */
4717                 "RANfunctionID"
4718                 },
4719         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs__value, choice.RICsubscriptionDetails),
4720                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4721                 0,
4722                 &asn_DEF_RICsubscriptionDetails,
4723                 0,
4724                 { 0, 0, 0 },
4725                 0, 0, /* No default value */
4726                 "RICsubscriptionDetails"
4727                 },
4728 };
4729 static const unsigned asn_MAP_value_to_canonical_28[] = { 1, 0, 2 };
4730 static const unsigned asn_MAP_value_from_canonical_28[] = { 1, 0, 2 };
4731 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_28[] = {
4732     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4733     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
4734     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* RICsubscriptionDetails */
4735 };
4736 static asn_CHOICE_specifics_t asn_SPC_value_specs_28 = {
4737         sizeof(struct RICsubscriptionRequest_IEs__value),
4738         offsetof(struct RICsubscriptionRequest_IEs__value, _asn_ctx),
4739         offsetof(struct RICsubscriptionRequest_IEs__value, present),
4740         sizeof(((struct RICsubscriptionRequest_IEs__value *)0)->present),
4741         asn_MAP_value_tag2el_28,
4742         3,      /* Count of tags in the map */
4743         asn_MAP_value_to_canonical_28,
4744         asn_MAP_value_from_canonical_28,
4745         -1      /* Extensions start */
4746 };
4747 static /* Use -fall-defs-global to expose */
4748 asn_TYPE_descriptor_t asn_DEF_value_28 = {
4749         "value",
4750         "value",
4751         &asn_OP_OPEN_TYPE,
4752         0,      /* No effective tags (pointer) */
4753         0,      /* No effective tags (count) */
4754         0,      /* No tags (pointer) */
4755         0,      /* No tags (count) */
4756         { 0, 0, OPEN_TYPE_constraint },
4757         asn_MBR_value_28,
4758         3,      /* Elements count */
4759         &asn_SPC_value_specs_28 /* Additional specs */
4760 };
4761
4762 asn_TYPE_member_t asn_MBR_RICsubscriptionRequest_IEs_25[] = {
4763         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, id),
4764                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4765                 -1,     /* IMPLICIT tag at current level */
4766                 &asn_DEF_ProtocolIE_ID,
4767                 0,
4768                 { 0, &asn_PER_memb_id_constr_26,  memb_id_constraint_25 },
4769                 0, 0, /* No default value */
4770                 "id"
4771                 },
4772         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, criticality),
4773                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4774                 -1,     /* IMPLICIT tag at current level */
4775                 &asn_DEF_Criticality,
4776                 select_RICsubscriptionRequest_IEs_criticality_type,
4777                 { 0, &asn_PER_memb_criticality_constr_27,  memb_criticality_constraint_25 },
4778                 0, 0, /* No default value */
4779                 "criticality"
4780                 },
4781         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionRequest_IEs, value),
4782                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4783                 +1,     /* EXPLICIT tag at current level */
4784                 &asn_DEF_value_28,
4785                 select_RICsubscriptionRequest_IEs_value_type,
4786                 { 0, &asn_PER_memb_value_constr_28,  memb_value_constraint_25 },
4787                 0, 0, /* No default value */
4788                 "value"
4789                 },
4790 };
4791 static const ber_tlv_tag_t asn_DEF_RICsubscriptionRequest_IEs_tags_25[] = {
4792         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4793 };
4794 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionRequest_IEs_tag2el_25[] = {
4795     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4796     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4797     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4798 };
4799 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionRequest_IEs_specs_25 = {
4800         sizeof(struct RICsubscriptionRequest_IEs),
4801         offsetof(struct RICsubscriptionRequest_IEs, _asn_ctx),
4802         asn_MAP_RICsubscriptionRequest_IEs_tag2el_25,
4803         3,      /* Count of tags in the map */
4804         0, 0, 0,        /* Optional elements (not needed) */
4805         -1,     /* First extension addition */
4806 };
4807 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionRequest_IEs = {
4808         "RICsubscriptionRequest-IEs",
4809         "RICsubscriptionRequest-IEs",
4810         &asn_OP_SEQUENCE,
4811         asn_DEF_RICsubscriptionRequest_IEs_tags_25,
4812         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25)
4813                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
4814         asn_DEF_RICsubscriptionRequest_IEs_tags_25,     /* Same as above */
4815         sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25)
4816                 /sizeof(asn_DEF_RICsubscriptionRequest_IEs_tags_25[0]), /* 1 */
4817         { 0, 0, SEQUENCE_constraint },
4818         asn_MBR_RICsubscriptionRequest_IEs_25,
4819         3,      /* Elements count */
4820         &asn_SPC_RICsubscriptionRequest_IEs_specs_25    /* Additional specs */
4821 };
4822
4823 static asn_TYPE_member_t asn_MBR_value_32[] = {
4824         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICrequestID),
4825                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4826                 0,
4827                 &asn_DEF_RICrequestID,
4828                 0,
4829                 { 0, 0, 0 },
4830                 0, 0, /* No default value */
4831                 "RICrequestID"
4832                 },
4833         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RANfunctionID),
4834                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4835                 0,
4836                 &asn_DEF_RANfunctionID,
4837                 0,
4838                 { 0, 0, 0 },
4839                 0, 0, /* No default value */
4840                 "RANfunctionID"
4841                 },
4842         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_Admitted_List),
4843                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4844                 0,
4845                 &asn_DEF_RICaction_Admitted_List,
4846                 0,
4847                 { 0, 0, 0 },
4848                 0, 0, /* No default value */
4849                 "RICaction-Admitted-List"
4850                 },
4851         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs__value, choice.RICaction_NotAdmitted_List),
4852                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4853                 0,
4854                 &asn_DEF_RICaction_NotAdmitted_List,
4855                 0,
4856                 { 0, 0, 0 },
4857                 0, 0, /* No default value */
4858                 "RICaction-NotAdmitted-List"
4859                 },
4860 };
4861 static const unsigned asn_MAP_value_to_canonical_32[] = { 1, 0, 2, 3 };
4862 static const unsigned asn_MAP_value_from_canonical_32[] = { 1, 0, 2, 3 };
4863 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_32[] = {
4864     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4865     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
4866     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-Admitted-List */
4867     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* RICaction-NotAdmitted-List */
4868 };
4869 static asn_CHOICE_specifics_t asn_SPC_value_specs_32 = {
4870         sizeof(struct RICsubscriptionResponse_IEs__value),
4871         offsetof(struct RICsubscriptionResponse_IEs__value, _asn_ctx),
4872         offsetof(struct RICsubscriptionResponse_IEs__value, present),
4873         sizeof(((struct RICsubscriptionResponse_IEs__value *)0)->present),
4874         asn_MAP_value_tag2el_32,
4875         4,      /* Count of tags in the map */
4876         asn_MAP_value_to_canonical_32,
4877         asn_MAP_value_from_canonical_32,
4878         -1      /* Extensions start */
4879 };
4880 static /* Use -fall-defs-global to expose */
4881 asn_TYPE_descriptor_t asn_DEF_value_32 = {
4882         "value",
4883         "value",
4884         &asn_OP_OPEN_TYPE,
4885         0,      /* No effective tags (pointer) */
4886         0,      /* No effective tags (count) */
4887         0,      /* No tags (pointer) */
4888         0,      /* No tags (count) */
4889         { 0, 0, OPEN_TYPE_constraint },
4890         asn_MBR_value_32,
4891         4,      /* Elements count */
4892         &asn_SPC_value_specs_32 /* Additional specs */
4893 };
4894
4895 asn_TYPE_member_t asn_MBR_RICsubscriptionResponse_IEs_29[] = {
4896         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, id),
4897                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
4898                 -1,     /* IMPLICIT tag at current level */
4899                 &asn_DEF_ProtocolIE_ID,
4900                 0,
4901                 { 0, &asn_PER_memb_id_constr_30,  memb_id_constraint_29 },
4902                 0, 0, /* No default value */
4903                 "id"
4904                 },
4905         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, criticality),
4906                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
4907                 -1,     /* IMPLICIT tag at current level */
4908                 &asn_DEF_Criticality,
4909                 select_RICsubscriptionResponse_IEs_criticality_type,
4910                 { 0, &asn_PER_memb_criticality_constr_31,  memb_criticality_constraint_29 },
4911                 0, 0, /* No default value */
4912                 "criticality"
4913                 },
4914         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionResponse_IEs, value),
4915                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
4916                 +1,     /* EXPLICIT tag at current level */
4917                 &asn_DEF_value_32,
4918                 select_RICsubscriptionResponse_IEs_value_type,
4919                 { 0, &asn_PER_memb_value_constr_32,  memb_value_constraint_29 },
4920                 0, 0, /* No default value */
4921                 "value"
4922                 },
4923 };
4924 static const ber_tlv_tag_t asn_DEF_RICsubscriptionResponse_IEs_tags_29[] = {
4925         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
4926 };
4927 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionResponse_IEs_tag2el_29[] = {
4928     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
4929     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
4930     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
4931 };
4932 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionResponse_IEs_specs_29 = {
4933         sizeof(struct RICsubscriptionResponse_IEs),
4934         offsetof(struct RICsubscriptionResponse_IEs, _asn_ctx),
4935         asn_MAP_RICsubscriptionResponse_IEs_tag2el_29,
4936         3,      /* Count of tags in the map */
4937         0, 0, 0,        /* Optional elements (not needed) */
4938         -1,     /* First extension addition */
4939 };
4940 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionResponse_IEs = {
4941         "RICsubscriptionResponse-IEs",
4942         "RICsubscriptionResponse-IEs",
4943         &asn_OP_SEQUENCE,
4944         asn_DEF_RICsubscriptionResponse_IEs_tags_29,
4945         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29)
4946                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
4947         asn_DEF_RICsubscriptionResponse_IEs_tags_29,    /* Same as above */
4948         sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29)
4949                 /sizeof(asn_DEF_RICsubscriptionResponse_IEs_tags_29[0]), /* 1 */
4950         { 0, 0, SEQUENCE_constraint },
4951         asn_MBR_RICsubscriptionResponse_IEs_29,
4952         3,      /* Elements count */
4953         &asn_SPC_RICsubscriptionResponse_IEs_specs_29   /* Additional specs */
4954 };
4955
4956 static asn_TYPE_member_t asn_MBR_value_36[] = {
4957         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICrequestID),
4958                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4959                 0,
4960                 &asn_DEF_RICrequestID,
4961                 0,
4962                 { 0, 0, 0 },
4963                 0, 0, /* No default value */
4964                 "RICrequestID"
4965                 },
4966         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RANfunctionID),
4967                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
4968                 0,
4969                 &asn_DEF_RANfunctionID,
4970                 0,
4971                 { 0, 0, 0 },
4972                 0, 0, /* No default value */
4973                 "RANfunctionID"
4974                 },
4975         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.RICaction_NotAdmitted_List),
4976                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4977                 0,
4978                 &asn_DEF_RICaction_NotAdmitted_List,
4979                 0,
4980                 { 0, 0, 0 },
4981                 0, 0, /* No default value */
4982                 "RICaction-NotAdmitted-List"
4983                 },
4984         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs__value, choice.CriticalityDiagnostics),
4985                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
4986                 0,
4987                 &asn_DEF_CriticalityDiagnostics,
4988                 0,
4989                 { 0, 0, 0 },
4990                 0, 0, /* No default value */
4991                 "CriticalityDiagnostics"
4992                 },
4993 };
4994 static const unsigned asn_MAP_value_to_canonical_36[] = { 1, 0, 2, 3 };
4995 static const unsigned asn_MAP_value_from_canonical_36[] = { 1, 0, 2, 3 };
4996 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_36[] = {
4997     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
4998     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* RICrequestID */
4999     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 1 }, /* RICaction-NotAdmitted-List */
5000     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -2, 0 } /* CriticalityDiagnostics */
5001 };
5002 static asn_CHOICE_specifics_t asn_SPC_value_specs_36 = {
5003         sizeof(struct RICsubscriptionFailure_IEs__value),
5004         offsetof(struct RICsubscriptionFailure_IEs__value, _asn_ctx),
5005         offsetof(struct RICsubscriptionFailure_IEs__value, present),
5006         sizeof(((struct RICsubscriptionFailure_IEs__value *)0)->present),
5007         asn_MAP_value_tag2el_36,
5008         4,      /* Count of tags in the map */
5009         asn_MAP_value_to_canonical_36,
5010         asn_MAP_value_from_canonical_36,
5011         -1      /* Extensions start */
5012 };
5013 static /* Use -fall-defs-global to expose */
5014 asn_TYPE_descriptor_t asn_DEF_value_36 = {
5015         "value",
5016         "value",
5017         &asn_OP_OPEN_TYPE,
5018         0,      /* No effective tags (pointer) */
5019         0,      /* No effective tags (count) */
5020         0,      /* No tags (pointer) */
5021         0,      /* No tags (count) */
5022         { 0, 0, OPEN_TYPE_constraint },
5023         asn_MBR_value_36,
5024         4,      /* Elements count */
5025         &asn_SPC_value_specs_36 /* Additional specs */
5026 };
5027
5028 asn_TYPE_member_t asn_MBR_RICsubscriptionFailure_IEs_33[] = {
5029         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, id),
5030                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5031                 -1,     /* IMPLICIT tag at current level */
5032                 &asn_DEF_ProtocolIE_ID,
5033                 0,
5034                 { 0, &asn_PER_memb_id_constr_34,  memb_id_constraint_33 },
5035                 0, 0, /* No default value */
5036                 "id"
5037                 },
5038         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, criticality),
5039                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5040                 -1,     /* IMPLICIT tag at current level */
5041                 &asn_DEF_Criticality,
5042                 select_RICsubscriptionFailure_IEs_criticality_type,
5043                 { 0, &asn_PER_memb_criticality_constr_35,  memb_criticality_constraint_33 },
5044                 0, 0, /* No default value */
5045                 "criticality"
5046                 },
5047         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionFailure_IEs, value),
5048                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5049                 +1,     /* EXPLICIT tag at current level */
5050                 &asn_DEF_value_36,
5051                 select_RICsubscriptionFailure_IEs_value_type,
5052                 { 0, &asn_PER_memb_value_constr_36,  memb_value_constraint_33 },
5053                 0, 0, /* No default value */
5054                 "value"
5055                 },
5056 };
5057 static const ber_tlv_tag_t asn_DEF_RICsubscriptionFailure_IEs_tags_33[] = {
5058         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5059 };
5060 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionFailure_IEs_tag2el_33[] = {
5061     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5062     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5063     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5064 };
5065 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionFailure_IEs_specs_33 = {
5066         sizeof(struct RICsubscriptionFailure_IEs),
5067         offsetof(struct RICsubscriptionFailure_IEs, _asn_ctx),
5068         asn_MAP_RICsubscriptionFailure_IEs_tag2el_33,
5069         3,      /* Count of tags in the map */
5070         0, 0, 0,        /* Optional elements (not needed) */
5071         -1,     /* First extension addition */
5072 };
5073 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionFailure_IEs = {
5074         "RICsubscriptionFailure-IEs",
5075         "RICsubscriptionFailure-IEs",
5076         &asn_OP_SEQUENCE,
5077         asn_DEF_RICsubscriptionFailure_IEs_tags_33,
5078         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33)
5079                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
5080         asn_DEF_RICsubscriptionFailure_IEs_tags_33,     /* Same as above */
5081         sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33)
5082                 /sizeof(asn_DEF_RICsubscriptionFailure_IEs_tags_33[0]), /* 1 */
5083         { 0, 0, SEQUENCE_constraint },
5084         asn_MBR_RICsubscriptionFailure_IEs_33,
5085         3,      /* Elements count */
5086         &asn_SPC_RICsubscriptionFailure_IEs_specs_33    /* Additional specs */
5087 };
5088
5089 static asn_TYPE_member_t asn_MBR_value_40[] = {
5090         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RICrequestID),
5091                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5092                 0,
5093                 &asn_DEF_RICrequestID,
5094                 0,
5095                 { 0, 0, 0 },
5096                 0, 0, /* No default value */
5097                 "RICrequestID"
5098                 },
5099         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs__value, choice.RANfunctionID),
5100                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5101                 0,
5102                 &asn_DEF_RANfunctionID,
5103                 0,
5104                 { 0, 0, 0 },
5105                 0, 0, /* No default value */
5106                 "RANfunctionID"
5107                 },
5108 };
5109 static const unsigned asn_MAP_value_to_canonical_40[] = { 1, 0 };
5110 static const unsigned asn_MAP_value_from_canonical_40[] = { 1, 0 };
5111 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_40[] = {
5112     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5113     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5114 };
5115 static asn_CHOICE_specifics_t asn_SPC_value_specs_40 = {
5116         sizeof(struct RICsubscriptionDeleteRequest_IEs__value),
5117         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, _asn_ctx),
5118         offsetof(struct RICsubscriptionDeleteRequest_IEs__value, present),
5119         sizeof(((struct RICsubscriptionDeleteRequest_IEs__value *)0)->present),
5120         asn_MAP_value_tag2el_40,
5121         2,      /* Count of tags in the map */
5122         asn_MAP_value_to_canonical_40,
5123         asn_MAP_value_from_canonical_40,
5124         -1      /* Extensions start */
5125 };
5126 static /* Use -fall-defs-global to expose */
5127 asn_TYPE_descriptor_t asn_DEF_value_40 = {
5128         "value",
5129         "value",
5130         &asn_OP_OPEN_TYPE,
5131         0,      /* No effective tags (pointer) */
5132         0,      /* No effective tags (count) */
5133         0,      /* No tags (pointer) */
5134         0,      /* No tags (count) */
5135         { 0, 0, OPEN_TYPE_constraint },
5136         asn_MBR_value_40,
5137         2,      /* Elements count */
5138         &asn_SPC_value_specs_40 /* Additional specs */
5139 };
5140
5141 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteRequest_IEs_37[] = {
5142         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, id),
5143                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5144                 -1,     /* IMPLICIT tag at current level */
5145                 &asn_DEF_ProtocolIE_ID,
5146                 0,
5147                 { 0, &asn_PER_memb_id_constr_38,  memb_id_constraint_37 },
5148                 0, 0, /* No default value */
5149                 "id"
5150                 },
5151         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, criticality),
5152                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5153                 -1,     /* IMPLICIT tag at current level */
5154                 &asn_DEF_Criticality,
5155                 select_RICsubscriptionDeleteRequest_IEs_criticality_type,
5156                 { 0, &asn_PER_memb_criticality_constr_39,  memb_criticality_constraint_37 },
5157                 0, 0, /* No default value */
5158                 "criticality"
5159                 },
5160         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteRequest_IEs, value),
5161                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5162                 +1,     /* EXPLICIT tag at current level */
5163                 &asn_DEF_value_40,
5164                 select_RICsubscriptionDeleteRequest_IEs_value_type,
5165                 { 0, &asn_PER_memb_value_constr_40,  memb_value_constraint_37 },
5166                 0, 0, /* No default value */
5167                 "value"
5168                 },
5169 };
5170 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[] = {
5171         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5172 };
5173 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_37[] = {
5174     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5175     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5176     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5177 };
5178 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_37 = {
5179         sizeof(struct RICsubscriptionDeleteRequest_IEs),
5180         offsetof(struct RICsubscriptionDeleteRequest_IEs, _asn_ctx),
5181         asn_MAP_RICsubscriptionDeleteRequest_IEs_tag2el_37,
5182         3,      /* Count of tags in the map */
5183         0, 0, 0,        /* Optional elements (not needed) */
5184         -1,     /* First extension addition */
5185 };
5186 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteRequest_IEs = {
5187         "RICsubscriptionDeleteRequest-IEs",
5188         "RICsubscriptionDeleteRequest-IEs",
5189         &asn_OP_SEQUENCE,
5190         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37,
5191         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37)
5192                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
5193         asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37,       /* Same as above */
5194         sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37)
5195                 /sizeof(asn_DEF_RICsubscriptionDeleteRequest_IEs_tags_37[0]), /* 1 */
5196         { 0, 0, SEQUENCE_constraint },
5197         asn_MBR_RICsubscriptionDeleteRequest_IEs_37,
5198         3,      /* Elements count */
5199         &asn_SPC_RICsubscriptionDeleteRequest_IEs_specs_37      /* Additional specs */
5200 };
5201
5202 static asn_TYPE_member_t asn_MBR_value_44[] = {
5203         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RICrequestID),
5204                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5205                 0,
5206                 &asn_DEF_RICrequestID,
5207                 0,
5208                 { 0, 0, 0 },
5209                 0, 0, /* No default value */
5210                 "RICrequestID"
5211                 },
5212         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs__value, choice.RANfunctionID),
5213                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5214                 0,
5215                 &asn_DEF_RANfunctionID,
5216                 0,
5217                 { 0, 0, 0 },
5218                 0, 0, /* No default value */
5219                 "RANfunctionID"
5220                 },
5221 };
5222 static const unsigned asn_MAP_value_to_canonical_44[] = { 1, 0 };
5223 static const unsigned asn_MAP_value_from_canonical_44[] = { 1, 0 };
5224 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_44[] = {
5225     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5226     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5227 };
5228 static asn_CHOICE_specifics_t asn_SPC_value_specs_44 = {
5229         sizeof(struct RICsubscriptionDeleteResponse_IEs__value),
5230         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, _asn_ctx),
5231         offsetof(struct RICsubscriptionDeleteResponse_IEs__value, present),
5232         sizeof(((struct RICsubscriptionDeleteResponse_IEs__value *)0)->present),
5233         asn_MAP_value_tag2el_44,
5234         2,      /* Count of tags in the map */
5235         asn_MAP_value_to_canonical_44,
5236         asn_MAP_value_from_canonical_44,
5237         -1      /* Extensions start */
5238 };
5239 static /* Use -fall-defs-global to expose */
5240 asn_TYPE_descriptor_t asn_DEF_value_44 = {
5241         "value",
5242         "value",
5243         &asn_OP_OPEN_TYPE,
5244         0,      /* No effective tags (pointer) */
5245         0,      /* No effective tags (count) */
5246         0,      /* No tags (pointer) */
5247         0,      /* No tags (count) */
5248         { 0, 0, OPEN_TYPE_constraint },
5249         asn_MBR_value_44,
5250         2,      /* Elements count */
5251         &asn_SPC_value_specs_44 /* Additional specs */
5252 };
5253
5254 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteResponse_IEs_41[] = {
5255         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, id),
5256                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5257                 -1,     /* IMPLICIT tag at current level */
5258                 &asn_DEF_ProtocolIE_ID,
5259                 0,
5260                 { 0, &asn_PER_memb_id_constr_42,  memb_id_constraint_41 },
5261                 0, 0, /* No default value */
5262                 "id"
5263                 },
5264         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, criticality),
5265                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5266                 -1,     /* IMPLICIT tag at current level */
5267                 &asn_DEF_Criticality,
5268                 select_RICsubscriptionDeleteResponse_IEs_criticality_type,
5269                 { 0, &asn_PER_memb_criticality_constr_43,  memb_criticality_constraint_41 },
5270                 0, 0, /* No default value */
5271                 "criticality"
5272                 },
5273         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteResponse_IEs, value),
5274                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5275                 +1,     /* EXPLICIT tag at current level */
5276                 &asn_DEF_value_44,
5277                 select_RICsubscriptionDeleteResponse_IEs_value_type,
5278                 { 0, &asn_PER_memb_value_constr_44,  memb_value_constraint_41 },
5279                 0, 0, /* No default value */
5280                 "value"
5281                 },
5282 };
5283 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[] = {
5284         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5285 };
5286 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_41[] = {
5287     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5288     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5289     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5290 };
5291 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_41 = {
5292         sizeof(struct RICsubscriptionDeleteResponse_IEs),
5293         offsetof(struct RICsubscriptionDeleteResponse_IEs, _asn_ctx),
5294         asn_MAP_RICsubscriptionDeleteResponse_IEs_tag2el_41,
5295         3,      /* Count of tags in the map */
5296         0, 0, 0,        /* Optional elements (not needed) */
5297         -1,     /* First extension addition */
5298 };
5299 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteResponse_IEs = {
5300         "RICsubscriptionDeleteResponse-IEs",
5301         "RICsubscriptionDeleteResponse-IEs",
5302         &asn_OP_SEQUENCE,
5303         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41,
5304         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41)
5305                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
5306         asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41,      /* Same as above */
5307         sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41)
5308                 /sizeof(asn_DEF_RICsubscriptionDeleteResponse_IEs_tags_41[0]), /* 1 */
5309         { 0, 0, SEQUENCE_constraint },
5310         asn_MBR_RICsubscriptionDeleteResponse_IEs_41,
5311         3,      /* Elements count */
5312         &asn_SPC_RICsubscriptionDeleteResponse_IEs_specs_41     /* Additional specs */
5313 };
5314
5315 static asn_TYPE_member_t asn_MBR_value_48[] = {
5316         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RICrequestID),
5317                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5318                 0,
5319                 &asn_DEF_RICrequestID,
5320                 0,
5321                 { 0, 0, 0 },
5322                 0, 0, /* No default value */
5323                 "RICrequestID"
5324                 },
5325         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.RANfunctionID),
5326                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5327                 0,
5328                 &asn_DEF_RANfunctionID,
5329                 0,
5330                 { 0, 0, 0 },
5331                 0, 0, /* No default value */
5332                 "RANfunctionID"
5333                 },
5334         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.Cause),
5335                 -1 /* Ambiguous tag (CHOICE?) */,
5336                 0,
5337                 &asn_DEF_Cause,
5338                 0,
5339                 { 0, 0, 0 },
5340                 0, 0, /* No default value */
5341                 "Cause"
5342                 },
5343         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs__value, choice.CriticalityDiagnostics),
5344                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5345                 0,
5346                 &asn_DEF_CriticalityDiagnostics,
5347                 0,
5348                 { 0, 0, 0 },
5349                 0, 0, /* No default value */
5350                 "CriticalityDiagnostics"
5351                 },
5352 };
5353 static const unsigned asn_MAP_value_to_canonical_48[] = { 1, 0, 3, 2 };
5354 static const unsigned asn_MAP_value_from_canonical_48[] = { 1, 0, 3, 2 };
5355 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_48[] = {
5356     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5357     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
5358     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
5359     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
5360     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
5361     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
5362     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
5363     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
5364 };
5365 static asn_CHOICE_specifics_t asn_SPC_value_specs_48 = {
5366         sizeof(struct RICsubscriptionDeleteFailure_IEs__value),
5367         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, _asn_ctx),
5368         offsetof(struct RICsubscriptionDeleteFailure_IEs__value, present),
5369         sizeof(((struct RICsubscriptionDeleteFailure_IEs__value *)0)->present),
5370         asn_MAP_value_tag2el_48,
5371         8,      /* Count of tags in the map */
5372         asn_MAP_value_to_canonical_48,
5373         asn_MAP_value_from_canonical_48,
5374         -1      /* Extensions start */
5375 };
5376 static /* Use -fall-defs-global to expose */
5377 asn_TYPE_descriptor_t asn_DEF_value_48 = {
5378         "value",
5379         "value",
5380         &asn_OP_OPEN_TYPE,
5381         0,      /* No effective tags (pointer) */
5382         0,      /* No effective tags (count) */
5383         0,      /* No tags (pointer) */
5384         0,      /* No tags (count) */
5385         { 0, 0, OPEN_TYPE_constraint },
5386         asn_MBR_value_48,
5387         4,      /* Elements count */
5388         &asn_SPC_value_specs_48 /* Additional specs */
5389 };
5390
5391 asn_TYPE_member_t asn_MBR_RICsubscriptionDeleteFailure_IEs_45[] = {
5392         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, id),
5393                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5394                 -1,     /* IMPLICIT tag at current level */
5395                 &asn_DEF_ProtocolIE_ID,
5396                 0,
5397                 { 0, &asn_PER_memb_id_constr_46,  memb_id_constraint_45 },
5398                 0, 0, /* No default value */
5399                 "id"
5400                 },
5401         { ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, criticality),
5402                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5403                 -1,     /* IMPLICIT tag at current level */
5404                 &asn_DEF_Criticality,
5405                 select_RICsubscriptionDeleteFailure_IEs_criticality_type,
5406                 { 0, &asn_PER_memb_criticality_constr_47,  memb_criticality_constraint_45 },
5407                 0, 0, /* No default value */
5408                 "criticality"
5409                 },
5410         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICsubscriptionDeleteFailure_IEs, value),
5411                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5412                 +1,     /* EXPLICIT tag at current level */
5413                 &asn_DEF_value_48,
5414                 select_RICsubscriptionDeleteFailure_IEs_value_type,
5415                 { 0, &asn_PER_memb_value_constr_48,  memb_value_constraint_45 },
5416                 0, 0, /* No default value */
5417                 "value"
5418                 },
5419 };
5420 static const ber_tlv_tag_t asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[] = {
5421         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5422 };
5423 static const asn_TYPE_tag2member_t asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_45[] = {
5424     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5425     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5426     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5427 };
5428 asn_SEQUENCE_specifics_t asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_45 = {
5429         sizeof(struct RICsubscriptionDeleteFailure_IEs),
5430         offsetof(struct RICsubscriptionDeleteFailure_IEs, _asn_ctx),
5431         asn_MAP_RICsubscriptionDeleteFailure_IEs_tag2el_45,
5432         3,      /* Count of tags in the map */
5433         0, 0, 0,        /* Optional elements (not needed) */
5434         -1,     /* First extension addition */
5435 };
5436 asn_TYPE_descriptor_t asn_DEF_RICsubscriptionDeleteFailure_IEs = {
5437         "RICsubscriptionDeleteFailure-IEs",
5438         "RICsubscriptionDeleteFailure-IEs",
5439         &asn_OP_SEQUENCE,
5440         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45,
5441         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45)
5442                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
5443         asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45,       /* Same as above */
5444         sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45)
5445                 /sizeof(asn_DEF_RICsubscriptionDeleteFailure_IEs_tags_45[0]), /* 1 */
5446         { 0, 0, SEQUENCE_constraint },
5447         asn_MBR_RICsubscriptionDeleteFailure_IEs_45,
5448         3,      /* Elements count */
5449         &asn_SPC_RICsubscriptionDeleteFailure_IEs_specs_45      /* Additional specs */
5450 };
5451
5452 static asn_TYPE_member_t asn_MBR_value_52[] = {
5453         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICrequestID),
5454                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5455                 0,
5456                 &asn_DEF_RICrequestID,
5457                 0,
5458                 { 0, 0, 0 },
5459                 0, 0, /* No default value */
5460                 "RICrequestID"
5461                 },
5462         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RANfunctionID),
5463                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5464                 0,
5465                 &asn_DEF_RANfunctionID,
5466                 0,
5467                 { 0, 0, 0 },
5468                 0, 0, /* No default value */
5469                 "RANfunctionID"
5470                 },
5471         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICactionID),
5472                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5473                 0,
5474                 &asn_DEF_RICactionID,
5475                 0,
5476                 { 0, 0, 0 },
5477                 0, 0, /* No default value */
5478                 "RICactionID"
5479                 },
5480         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationSN),
5481                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5482                 0,
5483                 &asn_DEF_RICindicationSN,
5484                 0,
5485                 { 0, 0, 0 },
5486                 0, 0, /* No default value */
5487                 "RICindicationSN"
5488                 },
5489         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationType),
5490                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5491                 0,
5492                 &asn_DEF_RICindicationType,
5493                 0,
5494                 { 0, 0, 0 },
5495                 0, 0, /* No default value */
5496                 "RICindicationType"
5497                 },
5498         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationHeader),
5499                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5500                 0,
5501                 &asn_DEF_RICindicationHeader,
5502                 0,
5503                 { 0, 0, 0 },
5504                 0, 0, /* No default value */
5505                 "RICindicationHeader"
5506                 },
5507         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICindicationMessage),
5508                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5509                 0,
5510                 &asn_DEF_RICindicationMessage,
5511                 0,
5512                 { 0, 0, 0 },
5513                 0, 0, /* No default value */
5514                 "RICindicationMessage"
5515                 },
5516         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs__value, choice.RICcallProcessID),
5517                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5518                 0,
5519                 &asn_DEF_RICcallProcessID,
5520                 0,
5521                 { 0, 0, 0 },
5522                 0, 0, /* No default value */
5523                 "RICcallProcessID"
5524                 },
5525 };
5526 static const unsigned asn_MAP_value_to_canonical_52[] = { 1, 2, 3, 5, 6, 7, 4, 0 };
5527 static const unsigned asn_MAP_value_from_canonical_52[] = { 7, 0, 1, 2, 6, 3, 4, 5 };
5528 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_52[] = {
5529     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 2 }, /* RANfunctionID */
5530     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* RICactionID */
5531     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 0 }, /* RICindicationSN */
5532     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 5, 0, 2 }, /* RICindicationHeader */
5533     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 6, -1, 1 }, /* RICindicationMessage */
5534     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 7, -2, 0 }, /* RICcallProcessID */
5535     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* RICindicationType */
5536     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5537 };
5538 static asn_CHOICE_specifics_t asn_SPC_value_specs_52 = {
5539         sizeof(struct RICindication_IEs__value),
5540         offsetof(struct RICindication_IEs__value, _asn_ctx),
5541         offsetof(struct RICindication_IEs__value, present),
5542         sizeof(((struct RICindication_IEs__value *)0)->present),
5543         asn_MAP_value_tag2el_52,
5544         8,      /* Count of tags in the map */
5545         asn_MAP_value_to_canonical_52,
5546         asn_MAP_value_from_canonical_52,
5547         -1      /* Extensions start */
5548 };
5549 static /* Use -fall-defs-global to expose */
5550 asn_TYPE_descriptor_t asn_DEF_value_52 = {
5551         "value",
5552         "value",
5553         &asn_OP_OPEN_TYPE,
5554         0,      /* No effective tags (pointer) */
5555         0,      /* No effective tags (count) */
5556         0,      /* No tags (pointer) */
5557         0,      /* No tags (count) */
5558         { 0, 0, OPEN_TYPE_constraint },
5559         asn_MBR_value_52,
5560         8,      /* Elements count */
5561         &asn_SPC_value_specs_52 /* Additional specs */
5562 };
5563
5564 asn_TYPE_member_t asn_MBR_RICindication_IEs_49[] = {
5565         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, id),
5566                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5567                 -1,     /* IMPLICIT tag at current level */
5568                 &asn_DEF_ProtocolIE_ID,
5569                 0,
5570                 { 0, &asn_PER_memb_id_constr_50,  memb_id_constraint_49 },
5571                 0, 0, /* No default value */
5572                 "id"
5573                 },
5574         { ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, criticality),
5575                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5576                 -1,     /* IMPLICIT tag at current level */
5577                 &asn_DEF_Criticality,
5578                 select_RICindication_IEs_criticality_type,
5579                 { 0, &asn_PER_memb_criticality_constr_51,  memb_criticality_constraint_49 },
5580                 0, 0, /* No default value */
5581                 "criticality"
5582                 },
5583         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICindication_IEs, value),
5584                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5585                 +1,     /* EXPLICIT tag at current level */
5586                 &asn_DEF_value_52,
5587                 select_RICindication_IEs_value_type,
5588                 { 0, &asn_PER_memb_value_constr_52,  memb_value_constraint_49 },
5589                 0, 0, /* No default value */
5590                 "value"
5591                 },
5592 };
5593 static const ber_tlv_tag_t asn_DEF_RICindication_IEs_tags_49[] = {
5594         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5595 };
5596 static const asn_TYPE_tag2member_t asn_MAP_RICindication_IEs_tag2el_49[] = {
5597     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5598     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5599     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5600 };
5601 asn_SEQUENCE_specifics_t asn_SPC_RICindication_IEs_specs_49 = {
5602         sizeof(struct RICindication_IEs),
5603         offsetof(struct RICindication_IEs, _asn_ctx),
5604         asn_MAP_RICindication_IEs_tag2el_49,
5605         3,      /* Count of tags in the map */
5606         0, 0, 0,        /* Optional elements (not needed) */
5607         -1,     /* First extension addition */
5608 };
5609 asn_TYPE_descriptor_t asn_DEF_RICindication_IEs = {
5610         "RICindication-IEs",
5611         "RICindication-IEs",
5612         &asn_OP_SEQUENCE,
5613         asn_DEF_RICindication_IEs_tags_49,
5614         sizeof(asn_DEF_RICindication_IEs_tags_49)
5615                 /sizeof(asn_DEF_RICindication_IEs_tags_49[0]), /* 1 */
5616         asn_DEF_RICindication_IEs_tags_49,      /* Same as above */
5617         sizeof(asn_DEF_RICindication_IEs_tags_49)
5618                 /sizeof(asn_DEF_RICindication_IEs_tags_49[0]), /* 1 */
5619         { 0, 0, SEQUENCE_constraint },
5620         asn_MBR_RICindication_IEs_49,
5621         3,      /* Elements count */
5622         &asn_SPC_RICindication_IEs_specs_49     /* Additional specs */
5623 };
5624
5625 static asn_TYPE_member_t asn_MBR_value_56[] = {
5626         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICrequestID),
5627                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5628                 0,
5629                 &asn_DEF_RICrequestID,
5630                 0,
5631                 { 0, 0, 0 },
5632                 0, 0, /* No default value */
5633                 "RICrequestID"
5634                 },
5635         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RANfunctionID),
5636                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5637                 0,
5638                 &asn_DEF_RANfunctionID,
5639                 0,
5640                 { 0, 0, 0 },
5641                 0, 0, /* No default value */
5642                 "RANfunctionID"
5643                 },
5644         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcallProcessID),
5645                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5646                 0,
5647                 &asn_DEF_RICcallProcessID,
5648                 0,
5649                 { 0, 0, 0 },
5650                 0, 0, /* No default value */
5651                 "RICcallProcessID"
5652                 },
5653         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolHeader),
5654                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5655                 0,
5656                 &asn_DEF_RICcontrolHeader,
5657                 0,
5658                 { 0, 0, 0 },
5659                 0, 0, /* No default value */
5660                 "RICcontrolHeader"
5661                 },
5662         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolMessage),
5663                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5664                 0,
5665                 &asn_DEF_RICcontrolMessage,
5666                 0,
5667                 { 0, 0, 0 },
5668                 0, 0, /* No default value */
5669                 "RICcontrolMessage"
5670                 },
5671         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs__value, choice.RICcontrolAckRequest),
5672                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5673                 0,
5674                 &asn_DEF_RICcontrolAckRequest,
5675                 0,
5676                 { 0, 0, 0 },
5677                 0, 0, /* No default value */
5678                 "RICcontrolAckRequest"
5679                 },
5680 };
5681 static const unsigned asn_MAP_value_to_canonical_56[] = { 1, 2, 3, 4, 5, 0 };
5682 static const unsigned asn_MAP_value_from_canonical_56[] = { 5, 0, 1, 2, 3, 4 };
5683 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_56[] = {
5684     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5685     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 2 }, /* RICcallProcessID */
5686     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 1 }, /* RICcontrolHeader */
5687     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -2, 0 }, /* RICcontrolMessage */
5688     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 5, 0, 0 }, /* RICcontrolAckRequest */
5689     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5690 };
5691 static asn_CHOICE_specifics_t asn_SPC_value_specs_56 = {
5692         sizeof(struct RICcontrolRequest_IEs__value),
5693         offsetof(struct RICcontrolRequest_IEs__value, _asn_ctx),
5694         offsetof(struct RICcontrolRequest_IEs__value, present),
5695         sizeof(((struct RICcontrolRequest_IEs__value *)0)->present),
5696         asn_MAP_value_tag2el_56,
5697         6,      /* Count of tags in the map */
5698         asn_MAP_value_to_canonical_56,
5699         asn_MAP_value_from_canonical_56,
5700         -1      /* Extensions start */
5701 };
5702 static /* Use -fall-defs-global to expose */
5703 asn_TYPE_descriptor_t asn_DEF_value_56 = {
5704         "value",
5705         "value",
5706         &asn_OP_OPEN_TYPE,
5707         0,      /* No effective tags (pointer) */
5708         0,      /* No effective tags (count) */
5709         0,      /* No tags (pointer) */
5710         0,      /* No tags (count) */
5711         { 0, 0, OPEN_TYPE_constraint },
5712         asn_MBR_value_56,
5713         6,      /* Elements count */
5714         &asn_SPC_value_specs_56 /* Additional specs */
5715 };
5716
5717 asn_TYPE_member_t asn_MBR_RICcontrolRequest_IEs_53[] = {
5718         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, id),
5719                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5720                 -1,     /* IMPLICIT tag at current level */
5721                 &asn_DEF_ProtocolIE_ID,
5722                 0,
5723                 { 0, &asn_PER_memb_id_constr_54,  memb_id_constraint_53 },
5724                 0, 0, /* No default value */
5725                 "id"
5726                 },
5727         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, criticality),
5728                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5729                 -1,     /* IMPLICIT tag at current level */
5730                 &asn_DEF_Criticality,
5731                 select_RICcontrolRequest_IEs_criticality_type,
5732                 { 0, &asn_PER_memb_criticality_constr_55,  memb_criticality_constraint_53 },
5733                 0, 0, /* No default value */
5734                 "criticality"
5735                 },
5736         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolRequest_IEs, value),
5737                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5738                 +1,     /* EXPLICIT tag at current level */
5739                 &asn_DEF_value_56,
5740                 select_RICcontrolRequest_IEs_value_type,
5741                 { 0, &asn_PER_memb_value_constr_56,  memb_value_constraint_53 },
5742                 0, 0, /* No default value */
5743                 "value"
5744                 },
5745 };
5746 static const ber_tlv_tag_t asn_DEF_RICcontrolRequest_IEs_tags_53[] = {
5747         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5748 };
5749 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolRequest_IEs_tag2el_53[] = {
5750     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5751     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5752     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5753 };
5754 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolRequest_IEs_specs_53 = {
5755         sizeof(struct RICcontrolRequest_IEs),
5756         offsetof(struct RICcontrolRequest_IEs, _asn_ctx),
5757         asn_MAP_RICcontrolRequest_IEs_tag2el_53,
5758         3,      /* Count of tags in the map */
5759         0, 0, 0,        /* Optional elements (not needed) */
5760         -1,     /* First extension addition */
5761 };
5762 asn_TYPE_descriptor_t asn_DEF_RICcontrolRequest_IEs = {
5763         "RICcontrolRequest-IEs",
5764         "RICcontrolRequest-IEs",
5765         &asn_OP_SEQUENCE,
5766         asn_DEF_RICcontrolRequest_IEs_tags_53,
5767         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53)
5768                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
5769         asn_DEF_RICcontrolRequest_IEs_tags_53,  /* Same as above */
5770         sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53)
5771                 /sizeof(asn_DEF_RICcontrolRequest_IEs_tags_53[0]), /* 1 */
5772         { 0, 0, SEQUENCE_constraint },
5773         asn_MBR_RICcontrolRequest_IEs_53,
5774         3,      /* Elements count */
5775         &asn_SPC_RICcontrolRequest_IEs_specs_53 /* Additional specs */
5776 };
5777
5778 static asn_TYPE_member_t asn_MBR_value_60[] = {
5779         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICrequestID),
5780                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5781                 0,
5782                 &asn_DEF_RICrequestID,
5783                 0,
5784                 { 0, 0, 0 },
5785                 0, 0, /* No default value */
5786                 "RICrequestID"
5787                 },
5788         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RANfunctionID),
5789                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5790                 0,
5791                 &asn_DEF_RANfunctionID,
5792                 0,
5793                 { 0, 0, 0 },
5794                 0, 0, /* No default value */
5795                 "RANfunctionID"
5796                 },
5797         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcallProcessID),
5798                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5799                 0,
5800                 &asn_DEF_RICcallProcessID,
5801                 0,
5802                 { 0, 0, 0 },
5803                 0, 0, /* No default value */
5804                 "RICcallProcessID"
5805                 },
5806         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolStatus),
5807                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
5808                 0,
5809                 &asn_DEF_RICcontrolStatus,
5810                 0,
5811                 { 0, 0, 0 },
5812                 0, 0, /* No default value */
5813                 "RICcontrolStatus"
5814                 },
5815         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs__value, choice.RICcontrolOutcome),
5816                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5817                 0,
5818                 &asn_DEF_RICcontrolOutcome,
5819                 0,
5820                 { 0, 0, 0 },
5821                 0, 0, /* No default value */
5822                 "RICcontrolOutcome"
5823                 },
5824 };
5825 static const unsigned asn_MAP_value_to_canonical_60[] = { 1, 2, 4, 3, 0 };
5826 static const unsigned asn_MAP_value_from_canonical_60[] = { 4, 0, 1, 3, 2 };
5827 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_60[] = {
5828     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5829     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
5830     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
5831     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 3, 0, 0 }, /* RICcontrolStatus */
5832     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RICrequestID */
5833 };
5834 static asn_CHOICE_specifics_t asn_SPC_value_specs_60 = {
5835         sizeof(struct RICcontrolAcknowledge_IEs__value),
5836         offsetof(struct RICcontrolAcknowledge_IEs__value, _asn_ctx),
5837         offsetof(struct RICcontrolAcknowledge_IEs__value, present),
5838         sizeof(((struct RICcontrolAcknowledge_IEs__value *)0)->present),
5839         asn_MAP_value_tag2el_60,
5840         5,      /* Count of tags in the map */
5841         asn_MAP_value_to_canonical_60,
5842         asn_MAP_value_from_canonical_60,
5843         -1      /* Extensions start */
5844 };
5845 static /* Use -fall-defs-global to expose */
5846 asn_TYPE_descriptor_t asn_DEF_value_60 = {
5847         "value",
5848         "value",
5849         &asn_OP_OPEN_TYPE,
5850         0,      /* No effective tags (pointer) */
5851         0,      /* No effective tags (count) */
5852         0,      /* No tags (pointer) */
5853         0,      /* No tags (count) */
5854         { 0, 0, OPEN_TYPE_constraint },
5855         asn_MBR_value_60,
5856         5,      /* Elements count */
5857         &asn_SPC_value_specs_60 /* Additional specs */
5858 };
5859
5860 asn_TYPE_member_t asn_MBR_RICcontrolAcknowledge_IEs_57[] = {
5861         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, id),
5862                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
5863                 -1,     /* IMPLICIT tag at current level */
5864                 &asn_DEF_ProtocolIE_ID,
5865                 0,
5866                 { 0, &asn_PER_memb_id_constr_58,  memb_id_constraint_57 },
5867                 0, 0, /* No default value */
5868                 "id"
5869                 },
5870         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, criticality),
5871                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
5872                 -1,     /* IMPLICIT tag at current level */
5873                 &asn_DEF_Criticality,
5874                 select_RICcontrolAcknowledge_IEs_criticality_type,
5875                 { 0, &asn_PER_memb_criticality_constr_59,  memb_criticality_constraint_57 },
5876                 0, 0, /* No default value */
5877                 "criticality"
5878                 },
5879         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolAcknowledge_IEs, value),
5880                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
5881                 +1,     /* EXPLICIT tag at current level */
5882                 &asn_DEF_value_60,
5883                 select_RICcontrolAcknowledge_IEs_value_type,
5884                 { 0, &asn_PER_memb_value_constr_60,  memb_value_constraint_57 },
5885                 0, 0, /* No default value */
5886                 "value"
5887                 },
5888 };
5889 static const ber_tlv_tag_t asn_DEF_RICcontrolAcknowledge_IEs_tags_57[] = {
5890         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
5891 };
5892 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolAcknowledge_IEs_tag2el_57[] = {
5893     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
5894     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
5895     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
5896 };
5897 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolAcknowledge_IEs_specs_57 = {
5898         sizeof(struct RICcontrolAcknowledge_IEs),
5899         offsetof(struct RICcontrolAcknowledge_IEs, _asn_ctx),
5900         asn_MAP_RICcontrolAcknowledge_IEs_tag2el_57,
5901         3,      /* Count of tags in the map */
5902         0, 0, 0,        /* Optional elements (not needed) */
5903         -1,     /* First extension addition */
5904 };
5905 asn_TYPE_descriptor_t asn_DEF_RICcontrolAcknowledge_IEs = {
5906         "RICcontrolAcknowledge-IEs",
5907         "RICcontrolAcknowledge-IEs",
5908         &asn_OP_SEQUENCE,
5909         asn_DEF_RICcontrolAcknowledge_IEs_tags_57,
5910         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57)
5911                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
5912         asn_DEF_RICcontrolAcknowledge_IEs_tags_57,      /* Same as above */
5913         sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57)
5914                 /sizeof(asn_DEF_RICcontrolAcknowledge_IEs_tags_57[0]), /* 1 */
5915         { 0, 0, SEQUENCE_constraint },
5916         asn_MBR_RICcontrolAcknowledge_IEs_57,
5917         3,      /* Elements count */
5918         &asn_SPC_RICcontrolAcknowledge_IEs_specs_57     /* Additional specs */
5919 };
5920
5921 static asn_TYPE_member_t asn_MBR_value_64[] = {
5922         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICrequestID),
5923                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
5924                 0,
5925                 &asn_DEF_RICrequestID,
5926                 0,
5927                 { 0, 0, 0 },
5928                 0, 0, /* No default value */
5929                 "RICrequestID"
5930                 },
5931         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RANfunctionID),
5932                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
5933                 0,
5934                 &asn_DEF_RANfunctionID,
5935                 0,
5936                 { 0, 0, 0 },
5937                 0, 0, /* No default value */
5938                 "RANfunctionID"
5939                 },
5940         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcallProcessID),
5941                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5942                 0,
5943                 &asn_DEF_RICcallProcessID,
5944                 0,
5945                 { 0, 0, 0 },
5946                 0, 0, /* No default value */
5947                 "RICcallProcessID"
5948                 },
5949         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.Cause),
5950                 -1 /* Ambiguous tag (CHOICE?) */,
5951                 0,
5952                 &asn_DEF_Cause,
5953                 0,
5954                 { 0, 0, 0 },
5955                 0, 0, /* No default value */
5956                 "Cause"
5957                 },
5958         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs__value, choice.RICcontrolOutcome),
5959                 (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
5960                 0,
5961                 &asn_DEF_RICcontrolOutcome,
5962                 0,
5963                 { 0, 0, 0 },
5964                 0, 0, /* No default value */
5965                 "RICcontrolOutcome"
5966                 },
5967 };
5968 static const unsigned asn_MAP_value_to_canonical_64[] = { 1, 2, 4, 0, 3 };
5969 static const unsigned asn_MAP_value_from_canonical_64[] = { 3, 0, 1, 4, 2 };
5970 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_64[] = {
5971     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
5972     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* RICcallProcessID */
5973     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 4, -1, 0 }, /* RICcontrolOutcome */
5974     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* RICrequestID */
5975     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 3, 0, 0 }, /* ricRequest */
5976     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* ricService */
5977     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 3, 0, 0 }, /* transport */
5978     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
5979     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* misc */
5980 };
5981 static asn_CHOICE_specifics_t asn_SPC_value_specs_64 = {
5982         sizeof(struct RICcontrolFailure_IEs__value),
5983         offsetof(struct RICcontrolFailure_IEs__value, _asn_ctx),
5984         offsetof(struct RICcontrolFailure_IEs__value, present),
5985         sizeof(((struct RICcontrolFailure_IEs__value *)0)->present),
5986         asn_MAP_value_tag2el_64,
5987         9,      /* Count of tags in the map */
5988         asn_MAP_value_to_canonical_64,
5989         asn_MAP_value_from_canonical_64,
5990         -1      /* Extensions start */
5991 };
5992 static /* Use -fall-defs-global to expose */
5993 asn_TYPE_descriptor_t asn_DEF_value_64 = {
5994         "value",
5995         "value",
5996         &asn_OP_OPEN_TYPE,
5997         0,      /* No effective tags (pointer) */
5998         0,      /* No effective tags (count) */
5999         0,      /* No tags (pointer) */
6000         0,      /* No tags (count) */
6001         { 0, 0, OPEN_TYPE_constraint },
6002         asn_MBR_value_64,
6003         5,      /* Elements count */
6004         &asn_SPC_value_specs_64 /* Additional specs */
6005 };
6006
6007 asn_TYPE_member_t asn_MBR_RICcontrolFailure_IEs_61[] = {
6008         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, id),
6009                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6010                 -1,     /* IMPLICIT tag at current level */
6011                 &asn_DEF_ProtocolIE_ID,
6012                 0,
6013                 { 0, &asn_PER_memb_id_constr_62,  memb_id_constraint_61 },
6014                 0, 0, /* No default value */
6015                 "id"
6016                 },
6017         { ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, criticality),
6018                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6019                 -1,     /* IMPLICIT tag at current level */
6020                 &asn_DEF_Criticality,
6021                 select_RICcontrolFailure_IEs_criticality_type,
6022                 { 0, &asn_PER_memb_criticality_constr_63,  memb_criticality_constraint_61 },
6023                 0, 0, /* No default value */
6024                 "criticality"
6025                 },
6026         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICcontrolFailure_IEs, value),
6027                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6028                 +1,     /* EXPLICIT tag at current level */
6029                 &asn_DEF_value_64,
6030                 select_RICcontrolFailure_IEs_value_type,
6031                 { 0, &asn_PER_memb_value_constr_64,  memb_value_constraint_61 },
6032                 0, 0, /* No default value */
6033                 "value"
6034                 },
6035 };
6036 static const ber_tlv_tag_t asn_DEF_RICcontrolFailure_IEs_tags_61[] = {
6037         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6038 };
6039 static const asn_TYPE_tag2member_t asn_MAP_RICcontrolFailure_IEs_tag2el_61[] = {
6040     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6041     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6042     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6043 };
6044 asn_SEQUENCE_specifics_t asn_SPC_RICcontrolFailure_IEs_specs_61 = {
6045         sizeof(struct RICcontrolFailure_IEs),
6046         offsetof(struct RICcontrolFailure_IEs, _asn_ctx),
6047         asn_MAP_RICcontrolFailure_IEs_tag2el_61,
6048         3,      /* Count of tags in the map */
6049         0, 0, 0,        /* Optional elements (not needed) */
6050         -1,     /* First extension addition */
6051 };
6052 asn_TYPE_descriptor_t asn_DEF_RICcontrolFailure_IEs = {
6053         "RICcontrolFailure-IEs",
6054         "RICcontrolFailure-IEs",
6055         &asn_OP_SEQUENCE,
6056         asn_DEF_RICcontrolFailure_IEs_tags_61,
6057         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61)
6058                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
6059         asn_DEF_RICcontrolFailure_IEs_tags_61,  /* Same as above */
6060         sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61)
6061                 /sizeof(asn_DEF_RICcontrolFailure_IEs_tags_61[0]), /* 1 */
6062         { 0, 0, SEQUENCE_constraint },
6063         asn_MBR_RICcontrolFailure_IEs_61,
6064         3,      /* Elements count */
6065         &asn_SPC_RICcontrolFailure_IEs_specs_61 /* Additional specs */
6066 };
6067
6068 static asn_TYPE_member_t asn_MBR_value_68[] = {
6069         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RICrequestID),
6070                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6071                 0,
6072                 &asn_DEF_RICrequestID,
6073                 0,
6074                 { 0, 0, 0 },
6075                 0, 0, /* No default value */
6076                 "RICrequestID"
6077                 },
6078         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.RANfunctionID),
6079                 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
6080                 0,
6081                 &asn_DEF_RANfunctionID,
6082                 0,
6083                 { 0, 0, 0 },
6084                 0, 0, /* No default value */
6085                 "RANfunctionID"
6086                 },
6087         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.Cause),
6088                 -1 /* Ambiguous tag (CHOICE?) */,
6089                 0,
6090                 &asn_DEF_Cause,
6091                 0,
6092                 { 0, 0, 0 },
6093                 0, 0, /* No default value */
6094                 "Cause"
6095                 },
6096         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs__value, choice.CriticalityDiagnostics),
6097                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6098                 0,
6099                 &asn_DEF_CriticalityDiagnostics,
6100                 0,
6101                 { 0, 0, 0 },
6102                 0, 0, /* No default value */
6103                 "CriticalityDiagnostics"
6104                 },
6105 };
6106 static const unsigned asn_MAP_value_to_canonical_68[] = { 1, 0, 3, 2 };
6107 static const unsigned asn_MAP_value_from_canonical_68[] = { 1, 0, 3, 2 };
6108 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_68[] = {
6109     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* RANfunctionID */
6110     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RICrequestID */
6111     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -1, 0 }, /* CriticalityDiagnostics */
6112     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* ricRequest */
6113     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 }, /* ricService */
6114     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
6115     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* protocol */
6116     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 2, 0, 0 } /* misc */
6117 };
6118 static asn_CHOICE_specifics_t asn_SPC_value_specs_68 = {
6119         sizeof(struct ErrorIndication_IEs__value),
6120         offsetof(struct ErrorIndication_IEs__value, _asn_ctx),
6121         offsetof(struct ErrorIndication_IEs__value, present),
6122         sizeof(((struct ErrorIndication_IEs__value *)0)->present),
6123         asn_MAP_value_tag2el_68,
6124         8,      /* Count of tags in the map */
6125         asn_MAP_value_to_canonical_68,
6126         asn_MAP_value_from_canonical_68,
6127         -1      /* Extensions start */
6128 };
6129 static /* Use -fall-defs-global to expose */
6130 asn_TYPE_descriptor_t asn_DEF_value_68 = {
6131         "value",
6132         "value",
6133         &asn_OP_OPEN_TYPE,
6134         0,      /* No effective tags (pointer) */
6135         0,      /* No effective tags (count) */
6136         0,      /* No tags (pointer) */
6137         0,      /* No tags (count) */
6138         { 0, 0, OPEN_TYPE_constraint },
6139         asn_MBR_value_68,
6140         4,      /* Elements count */
6141         &asn_SPC_value_specs_68 /* Additional specs */
6142 };
6143
6144 asn_TYPE_member_t asn_MBR_ErrorIndication_IEs_65[] = {
6145         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, id),
6146                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6147                 -1,     /* IMPLICIT tag at current level */
6148                 &asn_DEF_ProtocolIE_ID,
6149                 0,
6150                 { 0, &asn_PER_memb_id_constr_66,  memb_id_constraint_65 },
6151                 0, 0, /* No default value */
6152                 "id"
6153                 },
6154         { ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, criticality),
6155                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6156                 -1,     /* IMPLICIT tag at current level */
6157                 &asn_DEF_Criticality,
6158                 select_ErrorIndication_IEs_criticality_type,
6159                 { 0, &asn_PER_memb_criticality_constr_67,  memb_criticality_constraint_65 },
6160                 0, 0, /* No default value */
6161                 "criticality"
6162                 },
6163         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ErrorIndication_IEs, value),
6164                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6165                 +1,     /* EXPLICIT tag at current level */
6166                 &asn_DEF_value_68,
6167                 select_ErrorIndication_IEs_value_type,
6168                 { 0, &asn_PER_memb_value_constr_68,  memb_value_constraint_65 },
6169                 0, 0, /* No default value */
6170                 "value"
6171                 },
6172 };
6173 static const ber_tlv_tag_t asn_DEF_ErrorIndication_IEs_tags_65[] = {
6174         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6175 };
6176 static const asn_TYPE_tag2member_t asn_MAP_ErrorIndication_IEs_tag2el_65[] = {
6177     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6178     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6179     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6180 };
6181 asn_SEQUENCE_specifics_t asn_SPC_ErrorIndication_IEs_specs_65 = {
6182         sizeof(struct ErrorIndication_IEs),
6183         offsetof(struct ErrorIndication_IEs, _asn_ctx),
6184         asn_MAP_ErrorIndication_IEs_tag2el_65,
6185         3,      /* Count of tags in the map */
6186         0, 0, 0,        /* Optional elements (not needed) */
6187         -1,     /* First extension addition */
6188 };
6189 asn_TYPE_descriptor_t asn_DEF_ErrorIndication_IEs = {
6190         "ErrorIndication-IEs",
6191         "ErrorIndication-IEs",
6192         &asn_OP_SEQUENCE,
6193         asn_DEF_ErrorIndication_IEs_tags_65,
6194         sizeof(asn_DEF_ErrorIndication_IEs_tags_65)
6195                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_65[0]), /* 1 */
6196         asn_DEF_ErrorIndication_IEs_tags_65,    /* Same as above */
6197         sizeof(asn_DEF_ErrorIndication_IEs_tags_65)
6198                 /sizeof(asn_DEF_ErrorIndication_IEs_tags_65[0]), /* 1 */
6199         { 0, 0, SEQUENCE_constraint },
6200         asn_MBR_ErrorIndication_IEs_65,
6201         3,      /* Elements count */
6202         &asn_SPC_ErrorIndication_IEs_specs_65   /* Additional specs */
6203 };
6204
6205 static asn_TYPE_member_t asn_MBR_value_72[] = {
6206         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.GlobalE2node_ID),
6207                 -1 /* Ambiguous tag (CHOICE?) */,
6208                 0,
6209                 &asn_DEF_GlobalE2node_ID,
6210                 0,
6211                 { 0, 0, 0 },
6212                 0, 0, /* No default value */
6213                 "GlobalE2node-ID"
6214                 },
6215         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs__value, choice.RANfunctions_List),
6216                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6217                 0,
6218                 &asn_DEF_RANfunctions_List,
6219                 0,
6220                 { 0, 0, 0 },
6221                 0, 0, /* No default value */
6222                 "RANfunctions-List"
6223                 },
6224 };
6225 static const unsigned asn_MAP_value_to_canonical_72[] = { 1, 0 };
6226 static const unsigned asn_MAP_value_from_canonical_72[] = { 1, 0 };
6227 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_72[] = {
6228     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* RANfunctions-List */
6229     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gNB */
6230     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* en-gNB */
6231     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* ng-eNB */
6232     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 } /* eNB */
6233 };
6234 static asn_CHOICE_specifics_t asn_SPC_value_specs_72 = {
6235         sizeof(struct E2setupRequestIEs__value),
6236         offsetof(struct E2setupRequestIEs__value, _asn_ctx),
6237         offsetof(struct E2setupRequestIEs__value, present),
6238         sizeof(((struct E2setupRequestIEs__value *)0)->present),
6239         asn_MAP_value_tag2el_72,
6240         5,      /* Count of tags in the map */
6241         asn_MAP_value_to_canonical_72,
6242         asn_MAP_value_from_canonical_72,
6243         -1      /* Extensions start */
6244 };
6245 static /* Use -fall-defs-global to expose */
6246 asn_TYPE_descriptor_t asn_DEF_value_72 = {
6247         "value",
6248         "value",
6249         &asn_OP_OPEN_TYPE,
6250         0,      /* No effective tags (pointer) */
6251         0,      /* No effective tags (count) */
6252         0,      /* No tags (pointer) */
6253         0,      /* No tags (count) */
6254         { 0, 0, OPEN_TYPE_constraint },
6255         asn_MBR_value_72,
6256         2,      /* Elements count */
6257         &asn_SPC_value_specs_72 /* Additional specs */
6258 };
6259
6260 asn_TYPE_member_t asn_MBR_E2setupRequestIEs_69[] = {
6261         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, id),
6262                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6263                 -1,     /* IMPLICIT tag at current level */
6264                 &asn_DEF_ProtocolIE_ID,
6265                 0,
6266                 { 0, &asn_PER_memb_id_constr_70,  memb_id_constraint_69 },
6267                 0, 0, /* No default value */
6268                 "id"
6269                 },
6270         { ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, criticality),
6271                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6272                 -1,     /* IMPLICIT tag at current level */
6273                 &asn_DEF_Criticality,
6274                 select_E2setupRequestIEs_criticality_type,
6275                 { 0, &asn_PER_memb_criticality_constr_71,  memb_criticality_constraint_69 },
6276                 0, 0, /* No default value */
6277                 "criticality"
6278                 },
6279         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupRequestIEs, value),
6280                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6281                 +1,     /* EXPLICIT tag at current level */
6282                 &asn_DEF_value_72,
6283                 select_E2setupRequestIEs_value_type,
6284                 { 0, &asn_PER_memb_value_constr_72,  memb_value_constraint_69 },
6285                 0, 0, /* No default value */
6286                 "value"
6287                 },
6288 };
6289 static const ber_tlv_tag_t asn_DEF_E2setupRequestIEs_tags_69[] = {
6290         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6291 };
6292 static const asn_TYPE_tag2member_t asn_MAP_E2setupRequestIEs_tag2el_69[] = {
6293     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6294     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6295     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6296 };
6297 asn_SEQUENCE_specifics_t asn_SPC_E2setupRequestIEs_specs_69 = {
6298         sizeof(struct E2setupRequestIEs),
6299         offsetof(struct E2setupRequestIEs, _asn_ctx),
6300         asn_MAP_E2setupRequestIEs_tag2el_69,
6301         3,      /* Count of tags in the map */
6302         0, 0, 0,        /* Optional elements (not needed) */
6303         -1,     /* First extension addition */
6304 };
6305 asn_TYPE_descriptor_t asn_DEF_E2setupRequestIEs = {
6306         "E2setupRequestIEs",
6307         "E2setupRequestIEs",
6308         &asn_OP_SEQUENCE,
6309         asn_DEF_E2setupRequestIEs_tags_69,
6310         sizeof(asn_DEF_E2setupRequestIEs_tags_69)
6311                 /sizeof(asn_DEF_E2setupRequestIEs_tags_69[0]), /* 1 */
6312         asn_DEF_E2setupRequestIEs_tags_69,      /* Same as above */
6313         sizeof(asn_DEF_E2setupRequestIEs_tags_69)
6314                 /sizeof(asn_DEF_E2setupRequestIEs_tags_69[0]), /* 1 */
6315         { 0, 0, SEQUENCE_constraint },
6316         asn_MBR_E2setupRequestIEs_69,
6317         3,      /* Elements count */
6318         &asn_SPC_E2setupRequestIEs_specs_69     /* Additional specs */
6319 };
6320
6321 static asn_TYPE_member_t asn_MBR_value_76[] = {
6322         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.GlobalRIC_ID),
6323                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6324                 0,
6325                 &asn_DEF_GlobalRIC_ID,
6326                 0,
6327                 { 0, 0, 0 },
6328                 0, 0, /* No default value */
6329                 "GlobalRIC-ID"
6330                 },
6331         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsID_List),
6332                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6333                 0,
6334                 &asn_DEF_RANfunctionsID_List,
6335                 0,
6336                 { 0, 0, 0 },
6337                 0, 0, /* No default value */
6338                 "RANfunctionsID-List"
6339                 },
6340         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs__value, choice.RANfunctionsIDcause_List),
6341                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6342                 0,
6343                 &asn_DEF_RANfunctionsIDcause_List,
6344                 0,
6345                 { 0, 0, 0 },
6346                 0, 0, /* No default value */
6347                 "RANfunctionsIDcause-List"
6348                 },
6349 };
6350 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_76[] = {
6351     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 2 }, /* GlobalRIC-ID */
6352     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 1 }, /* RANfunctionsID-List */
6353     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -2, 0 } /* RANfunctionsIDcause-List */
6354 };
6355 static asn_CHOICE_specifics_t asn_SPC_value_specs_76 = {
6356         sizeof(struct E2setupResponseIEs__value),
6357         offsetof(struct E2setupResponseIEs__value, _asn_ctx),
6358         offsetof(struct E2setupResponseIEs__value, present),
6359         sizeof(((struct E2setupResponseIEs__value *)0)->present),
6360         asn_MAP_value_tag2el_76,
6361         3,      /* Count of tags in the map */
6362         0, 0,
6363         -1      /* Extensions start */
6364 };
6365 static /* Use -fall-defs-global to expose */
6366 asn_TYPE_descriptor_t asn_DEF_value_76 = {
6367         "value",
6368         "value",
6369         &asn_OP_OPEN_TYPE,
6370         0,      /* No effective tags (pointer) */
6371         0,      /* No effective tags (count) */
6372         0,      /* No tags (pointer) */
6373         0,      /* No tags (count) */
6374         { 0, 0, OPEN_TYPE_constraint },
6375         asn_MBR_value_76,
6376         3,      /* Elements count */
6377         &asn_SPC_value_specs_76 /* Additional specs */
6378 };
6379
6380 asn_TYPE_member_t asn_MBR_E2setupResponseIEs_73[] = {
6381         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, id),
6382                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6383                 -1,     /* IMPLICIT tag at current level */
6384                 &asn_DEF_ProtocolIE_ID,
6385                 0,
6386                 { 0, &asn_PER_memb_id_constr_74,  memb_id_constraint_73 },
6387                 0, 0, /* No default value */
6388                 "id"
6389                 },
6390         { ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, criticality),
6391                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6392                 -1,     /* IMPLICIT tag at current level */
6393                 &asn_DEF_Criticality,
6394                 select_E2setupResponseIEs_criticality_type,
6395                 { 0, &asn_PER_memb_criticality_constr_75,  memb_criticality_constraint_73 },
6396                 0, 0, /* No default value */
6397                 "criticality"
6398                 },
6399         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupResponseIEs, value),
6400                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6401                 +1,     /* EXPLICIT tag at current level */
6402                 &asn_DEF_value_76,
6403                 select_E2setupResponseIEs_value_type,
6404                 { 0, &asn_PER_memb_value_constr_76,  memb_value_constraint_73 },
6405                 0, 0, /* No default value */
6406                 "value"
6407                 },
6408 };
6409 static const ber_tlv_tag_t asn_DEF_E2setupResponseIEs_tags_73[] = {
6410         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6411 };
6412 static const asn_TYPE_tag2member_t asn_MAP_E2setupResponseIEs_tag2el_73[] = {
6413     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6414     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6415     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6416 };
6417 asn_SEQUENCE_specifics_t asn_SPC_E2setupResponseIEs_specs_73 = {
6418         sizeof(struct E2setupResponseIEs),
6419         offsetof(struct E2setupResponseIEs, _asn_ctx),
6420         asn_MAP_E2setupResponseIEs_tag2el_73,
6421         3,      /* Count of tags in the map */
6422         0, 0, 0,        /* Optional elements (not needed) */
6423         -1,     /* First extension addition */
6424 };
6425 asn_TYPE_descriptor_t asn_DEF_E2setupResponseIEs = {
6426         "E2setupResponseIEs",
6427         "E2setupResponseIEs",
6428         &asn_OP_SEQUENCE,
6429         asn_DEF_E2setupResponseIEs_tags_73,
6430         sizeof(asn_DEF_E2setupResponseIEs_tags_73)
6431                 /sizeof(asn_DEF_E2setupResponseIEs_tags_73[0]), /* 1 */
6432         asn_DEF_E2setupResponseIEs_tags_73,     /* Same as above */
6433         sizeof(asn_DEF_E2setupResponseIEs_tags_73)
6434                 /sizeof(asn_DEF_E2setupResponseIEs_tags_73[0]), /* 1 */
6435         { 0, 0, SEQUENCE_constraint },
6436         asn_MBR_E2setupResponseIEs_73,
6437         3,      /* Elements count */
6438         &asn_SPC_E2setupResponseIEs_specs_73    /* Additional specs */
6439 };
6440
6441 static asn_TYPE_member_t asn_MBR_value_80[] = {
6442         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.Cause),
6443                 -1 /* Ambiguous tag (CHOICE?) */,
6444                 0,
6445                 &asn_DEF_Cause,
6446                 0,
6447                 { 0, 0, 0 },
6448                 0, 0, /* No default value */
6449                 "Cause"
6450                 },
6451         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.TimeToWait),
6452                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
6453                 0,
6454                 &asn_DEF_TimeToWait,
6455                 0,
6456                 { 0, 0, 0 },
6457                 0, 0, /* No default value */
6458                 "TimeToWait"
6459                 },
6460         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs__value, choice.CriticalityDiagnostics),
6461                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6462                 0,
6463                 &asn_DEF_CriticalityDiagnostics,
6464                 0,
6465                 { 0, 0, 0 },
6466                 0, 0, /* No default value */
6467                 "CriticalityDiagnostics"
6468                 },
6469 };
6470 static const unsigned asn_MAP_value_to_canonical_80[] = { 1, 2, 0 };
6471 static const unsigned asn_MAP_value_from_canonical_80[] = { 2, 0, 1 };
6472 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_80[] = {
6473     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
6474     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 }, /* CriticalityDiagnostics */
6475     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
6476     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
6477     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
6478     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
6479     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
6480 };
6481 static asn_CHOICE_specifics_t asn_SPC_value_specs_80 = {
6482         sizeof(struct E2setupFailureIEs__value),
6483         offsetof(struct E2setupFailureIEs__value, _asn_ctx),
6484         offsetof(struct E2setupFailureIEs__value, present),
6485         sizeof(((struct E2setupFailureIEs__value *)0)->present),
6486         asn_MAP_value_tag2el_80,
6487         7,      /* Count of tags in the map */
6488         asn_MAP_value_to_canonical_80,
6489         asn_MAP_value_from_canonical_80,
6490         -1      /* Extensions start */
6491 };
6492 static /* Use -fall-defs-global to expose */
6493 asn_TYPE_descriptor_t asn_DEF_value_80 = {
6494         "value",
6495         "value",
6496         &asn_OP_OPEN_TYPE,
6497         0,      /* No effective tags (pointer) */
6498         0,      /* No effective tags (count) */
6499         0,      /* No tags (pointer) */
6500         0,      /* No tags (count) */
6501         { 0, 0, OPEN_TYPE_constraint },
6502         asn_MBR_value_80,
6503         3,      /* Elements count */
6504         &asn_SPC_value_specs_80 /* Additional specs */
6505 };
6506
6507 asn_TYPE_member_t asn_MBR_E2setupFailureIEs_77[] = {
6508         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, id),
6509                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6510                 -1,     /* IMPLICIT tag at current level */
6511                 &asn_DEF_ProtocolIE_ID,
6512                 0,
6513                 { 0, &asn_PER_memb_id_constr_78,  memb_id_constraint_77 },
6514                 0, 0, /* No default value */
6515                 "id"
6516                 },
6517         { ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, criticality),
6518                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6519                 -1,     /* IMPLICIT tag at current level */
6520                 &asn_DEF_Criticality,
6521                 select_E2setupFailureIEs_criticality_type,
6522                 { 0, &asn_PER_memb_criticality_constr_79,  memb_criticality_constraint_77 },
6523                 0, 0, /* No default value */
6524                 "criticality"
6525                 },
6526         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct E2setupFailureIEs, value),
6527                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6528                 +1,     /* EXPLICIT tag at current level */
6529                 &asn_DEF_value_80,
6530                 select_E2setupFailureIEs_value_type,
6531                 { 0, &asn_PER_memb_value_constr_80,  memb_value_constraint_77 },
6532                 0, 0, /* No default value */
6533                 "value"
6534                 },
6535 };
6536 static const ber_tlv_tag_t asn_DEF_E2setupFailureIEs_tags_77[] = {
6537         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6538 };
6539 static const asn_TYPE_tag2member_t asn_MAP_E2setupFailureIEs_tag2el_77[] = {
6540     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6541     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6542     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6543 };
6544 asn_SEQUENCE_specifics_t asn_SPC_E2setupFailureIEs_specs_77 = {
6545         sizeof(struct E2setupFailureIEs),
6546         offsetof(struct E2setupFailureIEs, _asn_ctx),
6547         asn_MAP_E2setupFailureIEs_tag2el_77,
6548         3,      /* Count of tags in the map */
6549         0, 0, 0,        /* Optional elements (not needed) */
6550         -1,     /* First extension addition */
6551 };
6552 asn_TYPE_descriptor_t asn_DEF_E2setupFailureIEs = {
6553         "E2setupFailureIEs",
6554         "E2setupFailureIEs",
6555         &asn_OP_SEQUENCE,
6556         asn_DEF_E2setupFailureIEs_tags_77,
6557         sizeof(asn_DEF_E2setupFailureIEs_tags_77)
6558                 /sizeof(asn_DEF_E2setupFailureIEs_tags_77[0]), /* 1 */
6559         asn_DEF_E2setupFailureIEs_tags_77,      /* Same as above */
6560         sizeof(asn_DEF_E2setupFailureIEs_tags_77)
6561                 /sizeof(asn_DEF_E2setupFailureIEs_tags_77[0]), /* 1 */
6562         { 0, 0, SEQUENCE_constraint },
6563         asn_MBR_E2setupFailureIEs_77,
6564         3,      /* Elements count */
6565         &asn_SPC_E2setupFailureIEs_specs_77     /* Additional specs */
6566 };
6567
6568 static asn_TYPE_member_t asn_MBR_value_84[] = {
6569         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs__value, choice.Cause),
6570                 -1 /* Ambiguous tag (CHOICE?) */,
6571                 0,
6572                 &asn_DEF_Cause,
6573                 0,
6574                 { 0, 0, 0 },
6575                 0, 0, /* No default value */
6576                 "Cause"
6577                 },
6578 };
6579 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_84[] = {
6580     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
6581     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* ricService */
6582     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 0 }, /* transport */
6583     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 }, /* protocol */
6584     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 0 } /* misc */
6585 };
6586 static asn_CHOICE_specifics_t asn_SPC_value_specs_84 = {
6587         sizeof(struct ResetRequestIEs__value),
6588         offsetof(struct ResetRequestIEs__value, _asn_ctx),
6589         offsetof(struct ResetRequestIEs__value, present),
6590         sizeof(((struct ResetRequestIEs__value *)0)->present),
6591         asn_MAP_value_tag2el_84,
6592         5,      /* Count of tags in the map */
6593         0, 0,
6594         -1      /* Extensions start */
6595 };
6596 static /* Use -fall-defs-global to expose */
6597 asn_TYPE_descriptor_t asn_DEF_value_84 = {
6598         "value",
6599         "value",
6600         &asn_OP_OPEN_TYPE,
6601         0,      /* No effective tags (pointer) */
6602         0,      /* No effective tags (count) */
6603         0,      /* No tags (pointer) */
6604         0,      /* No tags (count) */
6605         { 0, 0, OPEN_TYPE_constraint },
6606         asn_MBR_value_84,
6607         1,      /* Elements count */
6608         &asn_SPC_value_specs_84 /* Additional specs */
6609 };
6610
6611 asn_TYPE_member_t asn_MBR_ResetRequestIEs_81[] = {
6612         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, id),
6613                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6614                 -1,     /* IMPLICIT tag at current level */
6615                 &asn_DEF_ProtocolIE_ID,
6616                 0,
6617                 { 0, &asn_PER_memb_id_constr_82,  memb_id_constraint_81 },
6618                 0, 0, /* No default value */
6619                 "id"
6620                 },
6621         { ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, criticality),
6622                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6623                 -1,     /* IMPLICIT tag at current level */
6624                 &asn_DEF_Criticality,
6625                 select_ResetRequestIEs_criticality_type,
6626                 { 0, &asn_PER_memb_criticality_constr_83,  memb_criticality_constraint_81 },
6627                 0, 0, /* No default value */
6628                 "criticality"
6629                 },
6630         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetRequestIEs, value),
6631                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6632                 +1,     /* EXPLICIT tag at current level */
6633                 &asn_DEF_value_84,
6634                 select_ResetRequestIEs_value_type,
6635                 { 0, &asn_PER_memb_value_constr_84,  memb_value_constraint_81 },
6636                 0, 0, /* No default value */
6637                 "value"
6638                 },
6639 };
6640 static const ber_tlv_tag_t asn_DEF_ResetRequestIEs_tags_81[] = {
6641         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6642 };
6643 static const asn_TYPE_tag2member_t asn_MAP_ResetRequestIEs_tag2el_81[] = {
6644     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6645     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6646     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6647 };
6648 asn_SEQUENCE_specifics_t asn_SPC_ResetRequestIEs_specs_81 = {
6649         sizeof(struct ResetRequestIEs),
6650         offsetof(struct ResetRequestIEs, _asn_ctx),
6651         asn_MAP_ResetRequestIEs_tag2el_81,
6652         3,      /* Count of tags in the map */
6653         0, 0, 0,        /* Optional elements (not needed) */
6654         -1,     /* First extension addition */
6655 };
6656 asn_TYPE_descriptor_t asn_DEF_ResetRequestIEs = {
6657         "ResetRequestIEs",
6658         "ResetRequestIEs",
6659         &asn_OP_SEQUENCE,
6660         asn_DEF_ResetRequestIEs_tags_81,
6661         sizeof(asn_DEF_ResetRequestIEs_tags_81)
6662                 /sizeof(asn_DEF_ResetRequestIEs_tags_81[0]), /* 1 */
6663         asn_DEF_ResetRequestIEs_tags_81,        /* Same as above */
6664         sizeof(asn_DEF_ResetRequestIEs_tags_81)
6665                 /sizeof(asn_DEF_ResetRequestIEs_tags_81[0]), /* 1 */
6666         { 0, 0, SEQUENCE_constraint },
6667         asn_MBR_ResetRequestIEs_81,
6668         3,      /* Elements count */
6669         &asn_SPC_ResetRequestIEs_specs_81       /* Additional specs */
6670 };
6671
6672 static asn_TYPE_member_t asn_MBR_value_88[] = {
6673         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs__value, choice.CriticalityDiagnostics),
6674                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6675                 0,
6676                 &asn_DEF_CriticalityDiagnostics,
6677                 0,
6678                 { 0, 0, 0 },
6679                 0, 0, /* No default value */
6680                 "CriticalityDiagnostics"
6681                 },
6682 };
6683 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_88[] = {
6684     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* CriticalityDiagnostics */
6685 };
6686 static asn_CHOICE_specifics_t asn_SPC_value_specs_88 = {
6687         sizeof(struct ResetResponseIEs__value),
6688         offsetof(struct ResetResponseIEs__value, _asn_ctx),
6689         offsetof(struct ResetResponseIEs__value, present),
6690         sizeof(((struct ResetResponseIEs__value *)0)->present),
6691         asn_MAP_value_tag2el_88,
6692         1,      /* Count of tags in the map */
6693         0, 0,
6694         -1      /* Extensions start */
6695 };
6696 static /* Use -fall-defs-global to expose */
6697 asn_TYPE_descriptor_t asn_DEF_value_88 = {
6698         "value",
6699         "value",
6700         &asn_OP_OPEN_TYPE,
6701         0,      /* No effective tags (pointer) */
6702         0,      /* No effective tags (count) */
6703         0,      /* No tags (pointer) */
6704         0,      /* No tags (count) */
6705         { 0, 0, OPEN_TYPE_constraint },
6706         asn_MBR_value_88,
6707         1,      /* Elements count */
6708         &asn_SPC_value_specs_88 /* Additional specs */
6709 };
6710
6711 asn_TYPE_member_t asn_MBR_ResetResponseIEs_85[] = {
6712         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, id),
6713                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6714                 -1,     /* IMPLICIT tag at current level */
6715                 &asn_DEF_ProtocolIE_ID,
6716                 0,
6717                 { 0, &asn_PER_memb_id_constr_86,  memb_id_constraint_85 },
6718                 0, 0, /* No default value */
6719                 "id"
6720                 },
6721         { ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, criticality),
6722                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6723                 -1,     /* IMPLICIT tag at current level */
6724                 &asn_DEF_Criticality,
6725                 select_ResetResponseIEs_criticality_type,
6726                 { 0, &asn_PER_memb_criticality_constr_87,  memb_criticality_constraint_85 },
6727                 0, 0, /* No default value */
6728                 "criticality"
6729                 },
6730         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct ResetResponseIEs, value),
6731                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6732                 +1,     /* EXPLICIT tag at current level */
6733                 &asn_DEF_value_88,
6734                 select_ResetResponseIEs_value_type,
6735                 { 0, &asn_PER_memb_value_constr_88,  memb_value_constraint_85 },
6736                 0, 0, /* No default value */
6737                 "value"
6738                 },
6739 };
6740 static const ber_tlv_tag_t asn_DEF_ResetResponseIEs_tags_85[] = {
6741         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6742 };
6743 static const asn_TYPE_tag2member_t asn_MAP_ResetResponseIEs_tag2el_85[] = {
6744     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6745     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6746     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6747 };
6748 asn_SEQUENCE_specifics_t asn_SPC_ResetResponseIEs_specs_85 = {
6749         sizeof(struct ResetResponseIEs),
6750         offsetof(struct ResetResponseIEs, _asn_ctx),
6751         asn_MAP_ResetResponseIEs_tag2el_85,
6752         3,      /* Count of tags in the map */
6753         0, 0, 0,        /* Optional elements (not needed) */
6754         -1,     /* First extension addition */
6755 };
6756 asn_TYPE_descriptor_t asn_DEF_ResetResponseIEs = {
6757         "ResetResponseIEs",
6758         "ResetResponseIEs",
6759         &asn_OP_SEQUENCE,
6760         asn_DEF_ResetResponseIEs_tags_85,
6761         sizeof(asn_DEF_ResetResponseIEs_tags_85)
6762                 /sizeof(asn_DEF_ResetResponseIEs_tags_85[0]), /* 1 */
6763         asn_DEF_ResetResponseIEs_tags_85,       /* Same as above */
6764         sizeof(asn_DEF_ResetResponseIEs_tags_85)
6765                 /sizeof(asn_DEF_ResetResponseIEs_tags_85[0]), /* 1 */
6766         { 0, 0, SEQUENCE_constraint },
6767         asn_MBR_ResetResponseIEs_85,
6768         3,      /* Elements count */
6769         &asn_SPC_ResetResponseIEs_specs_85      /* Additional specs */
6770 };
6771
6772 static asn_TYPE_member_t asn_MBR_value_92[] = {
6773         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctions_List),
6774                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6775                 0,
6776                 &asn_DEF_RANfunctions_List,
6777                 0,
6778                 { 0, 0, 0 },
6779                 0, 0, /* No default value */
6780                 "RANfunctions-List"
6781                 },
6782         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs__value, choice.RANfunctionsID_List),
6783                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6784                 0,
6785                 &asn_DEF_RANfunctionsID_List,
6786                 0,
6787                 { 0, 0, 0 },
6788                 0, 0, /* No default value */
6789                 "RANfunctionsID-List"
6790                 },
6791 };
6792 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_92[] = {
6793     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctions-List */
6794     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsID-List */
6795 };
6796 static asn_CHOICE_specifics_t asn_SPC_value_specs_92 = {
6797         sizeof(struct RICserviceUpdate_IEs__value),
6798         offsetof(struct RICserviceUpdate_IEs__value, _asn_ctx),
6799         offsetof(struct RICserviceUpdate_IEs__value, present),
6800         sizeof(((struct RICserviceUpdate_IEs__value *)0)->present),
6801         asn_MAP_value_tag2el_92,
6802         2,      /* Count of tags in the map */
6803         0, 0,
6804         -1      /* Extensions start */
6805 };
6806 static /* Use -fall-defs-global to expose */
6807 asn_TYPE_descriptor_t asn_DEF_value_92 = {
6808         "value",
6809         "value",
6810         &asn_OP_OPEN_TYPE,
6811         0,      /* No effective tags (pointer) */
6812         0,      /* No effective tags (count) */
6813         0,      /* No tags (pointer) */
6814         0,      /* No tags (count) */
6815         { 0, 0, OPEN_TYPE_constraint },
6816         asn_MBR_value_92,
6817         2,      /* Elements count */
6818         &asn_SPC_value_specs_92 /* Additional specs */
6819 };
6820
6821 asn_TYPE_member_t asn_MBR_RICserviceUpdate_IEs_89[] = {
6822         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, id),
6823                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6824                 -1,     /* IMPLICIT tag at current level */
6825                 &asn_DEF_ProtocolIE_ID,
6826                 0,
6827                 { 0, &asn_PER_memb_id_constr_90,  memb_id_constraint_89 },
6828                 0, 0, /* No default value */
6829                 "id"
6830                 },
6831         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, criticality),
6832                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6833                 -1,     /* IMPLICIT tag at current level */
6834                 &asn_DEF_Criticality,
6835                 select_RICserviceUpdate_IEs_criticality_type,
6836                 { 0, &asn_PER_memb_criticality_constr_91,  memb_criticality_constraint_89 },
6837                 0, 0, /* No default value */
6838                 "criticality"
6839                 },
6840         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdate_IEs, value),
6841                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6842                 +1,     /* EXPLICIT tag at current level */
6843                 &asn_DEF_value_92,
6844                 select_RICserviceUpdate_IEs_value_type,
6845                 { 0, &asn_PER_memb_value_constr_92,  memb_value_constraint_89 },
6846                 0, 0, /* No default value */
6847                 "value"
6848                 },
6849 };
6850 static const ber_tlv_tag_t asn_DEF_RICserviceUpdate_IEs_tags_89[] = {
6851         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6852 };
6853 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdate_IEs_tag2el_89[] = {
6854     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6855     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6856     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6857 };
6858 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdate_IEs_specs_89 = {
6859         sizeof(struct RICserviceUpdate_IEs),
6860         offsetof(struct RICserviceUpdate_IEs, _asn_ctx),
6861         asn_MAP_RICserviceUpdate_IEs_tag2el_89,
6862         3,      /* Count of tags in the map */
6863         0, 0, 0,        /* Optional elements (not needed) */
6864         -1,     /* First extension addition */
6865 };
6866 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdate_IEs = {
6867         "RICserviceUpdate-IEs",
6868         "RICserviceUpdate-IEs",
6869         &asn_OP_SEQUENCE,
6870         asn_DEF_RICserviceUpdate_IEs_tags_89,
6871         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89)
6872                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89[0]), /* 1 */
6873         asn_DEF_RICserviceUpdate_IEs_tags_89,   /* Same as above */
6874         sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89)
6875                 /sizeof(asn_DEF_RICserviceUpdate_IEs_tags_89[0]), /* 1 */
6876         { 0, 0, SEQUENCE_constraint },
6877         asn_MBR_RICserviceUpdate_IEs_89,
6878         3,      /* Elements count */
6879         &asn_SPC_RICserviceUpdate_IEs_specs_89  /* Additional specs */
6880 };
6881
6882 static asn_TYPE_member_t asn_MBR_value_96[] = {
6883         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsID_List),
6884                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6885                 0,
6886                 &asn_DEF_RANfunctionsID_List,
6887                 0,
6888                 { 0, 0, 0 },
6889                 0, 0, /* No default value */
6890                 "RANfunctionsID-List"
6891                 },
6892         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs__value, choice.RANfunctionsIDcause_List),
6893                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6894                 0,
6895                 &asn_DEF_RANfunctionsIDcause_List,
6896                 0,
6897                 { 0, 0, 0 },
6898                 0, 0, /* No default value */
6899                 "RANfunctionsIDcause-List"
6900                 },
6901 };
6902 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_96[] = {
6903     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsID-List */
6904     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* RANfunctionsIDcause-List */
6905 };
6906 static asn_CHOICE_specifics_t asn_SPC_value_specs_96 = {
6907         sizeof(struct RICserviceUpdateAcknowledge_IEs__value),
6908         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, _asn_ctx),
6909         offsetof(struct RICserviceUpdateAcknowledge_IEs__value, present),
6910         sizeof(((struct RICserviceUpdateAcknowledge_IEs__value *)0)->present),
6911         asn_MAP_value_tag2el_96,
6912         2,      /* Count of tags in the map */
6913         0, 0,
6914         -1      /* Extensions start */
6915 };
6916 static /* Use -fall-defs-global to expose */
6917 asn_TYPE_descriptor_t asn_DEF_value_96 = {
6918         "value",
6919         "value",
6920         &asn_OP_OPEN_TYPE,
6921         0,      /* No effective tags (pointer) */
6922         0,      /* No effective tags (count) */
6923         0,      /* No tags (pointer) */
6924         0,      /* No tags (count) */
6925         { 0, 0, OPEN_TYPE_constraint },
6926         asn_MBR_value_96,
6927         2,      /* Elements count */
6928         &asn_SPC_value_specs_96 /* Additional specs */
6929 };
6930
6931 asn_TYPE_member_t asn_MBR_RICserviceUpdateAcknowledge_IEs_93[] = {
6932         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, id),
6933                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
6934                 -1,     /* IMPLICIT tag at current level */
6935                 &asn_DEF_ProtocolIE_ID,
6936                 0,
6937                 { 0, &asn_PER_memb_id_constr_94,  memb_id_constraint_93 },
6938                 0, 0, /* No default value */
6939                 "id"
6940                 },
6941         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, criticality),
6942                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
6943                 -1,     /* IMPLICIT tag at current level */
6944                 &asn_DEF_Criticality,
6945                 select_RICserviceUpdateAcknowledge_IEs_criticality_type,
6946                 { 0, &asn_PER_memb_criticality_constr_95,  memb_criticality_constraint_93 },
6947                 0, 0, /* No default value */
6948                 "criticality"
6949                 },
6950         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateAcknowledge_IEs, value),
6951                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
6952                 +1,     /* EXPLICIT tag at current level */
6953                 &asn_DEF_value_96,
6954                 select_RICserviceUpdateAcknowledge_IEs_value_type,
6955                 { 0, &asn_PER_memb_value_constr_96,  memb_value_constraint_93 },
6956                 0, 0, /* No default value */
6957                 "value"
6958                 },
6959 };
6960 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[] = {
6961         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
6962 };
6963 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_93[] = {
6964     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
6965     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
6966     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
6967 };
6968 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_93 = {
6969         sizeof(struct RICserviceUpdateAcknowledge_IEs),
6970         offsetof(struct RICserviceUpdateAcknowledge_IEs, _asn_ctx),
6971         asn_MAP_RICserviceUpdateAcknowledge_IEs_tag2el_93,
6972         3,      /* Count of tags in the map */
6973         0, 0, 0,        /* Optional elements (not needed) */
6974         -1,     /* First extension addition */
6975 };
6976 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateAcknowledge_IEs = {
6977         "RICserviceUpdateAcknowledge-IEs",
6978         "RICserviceUpdateAcknowledge-IEs",
6979         &asn_OP_SEQUENCE,
6980         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93,
6981         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93)
6982                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[0]), /* 1 */
6983         asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93,        /* Same as above */
6984         sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93)
6985                 /sizeof(asn_DEF_RICserviceUpdateAcknowledge_IEs_tags_93[0]), /* 1 */
6986         { 0, 0, SEQUENCE_constraint },
6987         asn_MBR_RICserviceUpdateAcknowledge_IEs_93,
6988         3,      /* Elements count */
6989         &asn_SPC_RICserviceUpdateAcknowledge_IEs_specs_93       /* Additional specs */
6990 };
6991
6992 static asn_TYPE_member_t asn_MBR_value_100[] = {
6993         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.RANfunctionsIDcause_List),
6994                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
6995                 0,
6996                 &asn_DEF_RANfunctionsIDcause_List,
6997                 0,
6998                 { 0, 0, 0 },
6999                 0, 0, /* No default value */
7000                 "RANfunctionsIDcause-List"
7001                 },
7002         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.TimeToWait),
7003                 (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
7004                 0,
7005                 &asn_DEF_TimeToWait,
7006                 0,
7007                 { 0, 0, 0 },
7008                 0, 0, /* No default value */
7009                 "TimeToWait"
7010                 },
7011         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs__value, choice.CriticalityDiagnostics),
7012                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7013                 0,
7014                 &asn_DEF_CriticalityDiagnostics,
7015                 0,
7016                 { 0, 0, 0 },
7017                 0, 0, /* No default value */
7018                 "CriticalityDiagnostics"
7019                 },
7020 };
7021 static const unsigned asn_MAP_value_to_canonical_100[] = { 1, 0, 2 };
7022 static const unsigned asn_MAP_value_from_canonical_100[] = { 1, 0, 2 };
7023 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_100[] = {
7024     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 1, 0, 0 }, /* TimeToWait */
7025     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* RANfunctionsIDcause-List */
7026     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 } /* CriticalityDiagnostics */
7027 };
7028 static asn_CHOICE_specifics_t asn_SPC_value_specs_100 = {
7029         sizeof(struct RICserviceUpdateFailure_IEs__value),
7030         offsetof(struct RICserviceUpdateFailure_IEs__value, _asn_ctx),
7031         offsetof(struct RICserviceUpdateFailure_IEs__value, present),
7032         sizeof(((struct RICserviceUpdateFailure_IEs__value *)0)->present),
7033         asn_MAP_value_tag2el_100,
7034         3,      /* Count of tags in the map */
7035         asn_MAP_value_to_canonical_100,
7036         asn_MAP_value_from_canonical_100,
7037         -1      /* Extensions start */
7038 };
7039 static /* Use -fall-defs-global to expose */
7040 asn_TYPE_descriptor_t asn_DEF_value_100 = {
7041         "value",
7042         "value",
7043         &asn_OP_OPEN_TYPE,
7044         0,      /* No effective tags (pointer) */
7045         0,      /* No effective tags (count) */
7046         0,      /* No tags (pointer) */
7047         0,      /* No tags (count) */
7048         { 0, 0, OPEN_TYPE_constraint },
7049         asn_MBR_value_100,
7050         3,      /* Elements count */
7051         &asn_SPC_value_specs_100        /* Additional specs */
7052 };
7053
7054 asn_TYPE_member_t asn_MBR_RICserviceUpdateFailure_IEs_97[] = {
7055         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, id),
7056                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
7057                 -1,     /* IMPLICIT tag at current level */
7058                 &asn_DEF_ProtocolIE_ID,
7059                 0,
7060                 { 0, &asn_PER_memb_id_constr_98,  memb_id_constraint_97 },
7061                 0, 0, /* No default value */
7062                 "id"
7063                 },
7064         { ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, criticality),
7065                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
7066                 -1,     /* IMPLICIT tag at current level */
7067                 &asn_DEF_Criticality,
7068                 select_RICserviceUpdateFailure_IEs_criticality_type,
7069                 { 0, &asn_PER_memb_criticality_constr_99,  memb_criticality_constraint_97 },
7070                 0, 0, /* No default value */
7071                 "criticality"
7072                 },
7073         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceUpdateFailure_IEs, value),
7074                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
7075                 +1,     /* EXPLICIT tag at current level */
7076                 &asn_DEF_value_100,
7077                 select_RICserviceUpdateFailure_IEs_value_type,
7078                 { 0, &asn_PER_memb_value_constr_100,  memb_value_constraint_97 },
7079                 0, 0, /* No default value */
7080                 "value"
7081                 },
7082 };
7083 static const ber_tlv_tag_t asn_DEF_RICserviceUpdateFailure_IEs_tags_97[] = {
7084         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7085 };
7086 static const asn_TYPE_tag2member_t asn_MAP_RICserviceUpdateFailure_IEs_tag2el_97[] = {
7087     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
7088     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
7089     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
7090 };
7091 asn_SEQUENCE_specifics_t asn_SPC_RICserviceUpdateFailure_IEs_specs_97 = {
7092         sizeof(struct RICserviceUpdateFailure_IEs),
7093         offsetof(struct RICserviceUpdateFailure_IEs, _asn_ctx),
7094         asn_MAP_RICserviceUpdateFailure_IEs_tag2el_97,
7095         3,      /* Count of tags in the map */
7096         0, 0, 0,        /* Optional elements (not needed) */
7097         -1,     /* First extension addition */
7098 };
7099 asn_TYPE_descriptor_t asn_DEF_RICserviceUpdateFailure_IEs = {
7100         "RICserviceUpdateFailure-IEs",
7101         "RICserviceUpdateFailure-IEs",
7102         &asn_OP_SEQUENCE,
7103         asn_DEF_RICserviceUpdateFailure_IEs_tags_97,
7104         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97)
7105                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97[0]), /* 1 */
7106         asn_DEF_RICserviceUpdateFailure_IEs_tags_97,    /* Same as above */
7107         sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97)
7108                 /sizeof(asn_DEF_RICserviceUpdateFailure_IEs_tags_97[0]), /* 1 */
7109         { 0, 0, SEQUENCE_constraint },
7110         asn_MBR_RICserviceUpdateFailure_IEs_97,
7111         3,      /* Elements count */
7112         &asn_SPC_RICserviceUpdateFailure_IEs_specs_97   /* Additional specs */
7113 };
7114
7115 static asn_TYPE_member_t asn_MBR_value_104[] = {
7116         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs__value, choice.RANfunctionsID_List),
7117                 (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
7118                 0,
7119                 &asn_DEF_RANfunctionsID_List,
7120                 0,
7121                 { 0, 0, 0 },
7122                 0, 0, /* No default value */
7123                 "RANfunctionsID-List"
7124                 },
7125 };
7126 static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_104[] = {
7127     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* RANfunctionsID-List */
7128 };
7129 static asn_CHOICE_specifics_t asn_SPC_value_specs_104 = {
7130         sizeof(struct RICserviceQuery_IEs__value),
7131         offsetof(struct RICserviceQuery_IEs__value, _asn_ctx),
7132         offsetof(struct RICserviceQuery_IEs__value, present),
7133         sizeof(((struct RICserviceQuery_IEs__value *)0)->present),
7134         asn_MAP_value_tag2el_104,
7135         1,      /* Count of tags in the map */
7136         0, 0,
7137         -1      /* Extensions start */
7138 };
7139 static /* Use -fall-defs-global to expose */
7140 asn_TYPE_descriptor_t asn_DEF_value_104 = {
7141         "value",
7142         "value",
7143         &asn_OP_OPEN_TYPE,
7144         0,      /* No effective tags (pointer) */
7145         0,      /* No effective tags (count) */
7146         0,      /* No tags (pointer) */
7147         0,      /* No tags (count) */
7148         { 0, 0, OPEN_TYPE_constraint },
7149         asn_MBR_value_104,
7150         1,      /* Elements count */
7151         &asn_SPC_value_specs_104        /* Additional specs */
7152 };
7153
7154 asn_TYPE_member_t asn_MBR_RICserviceQuery_IEs_101[] = {
7155         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, id),
7156                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
7157                 -1,     /* IMPLICIT tag at current level */
7158                 &asn_DEF_ProtocolIE_ID,
7159                 0,
7160                 { 0, &asn_PER_memb_id_constr_102,  memb_id_constraint_101 },
7161                 0, 0, /* No default value */
7162                 "id"
7163                 },
7164         { ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, criticality),
7165                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
7166                 -1,     /* IMPLICIT tag at current level */
7167                 &asn_DEF_Criticality,
7168                 select_RICserviceQuery_IEs_criticality_type,
7169                 { 0, &asn_PER_memb_criticality_constr_103,  memb_criticality_constraint_101 },
7170                 0, 0, /* No default value */
7171                 "criticality"
7172                 },
7173         { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct RICserviceQuery_IEs, value),
7174                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
7175                 +1,     /* EXPLICIT tag at current level */
7176                 &asn_DEF_value_104,
7177                 select_RICserviceQuery_IEs_value_type,
7178                 { 0, &asn_PER_memb_value_constr_104,  memb_value_constraint_101 },
7179                 0, 0, /* No default value */
7180                 "value"
7181                 },
7182 };
7183 static const ber_tlv_tag_t asn_DEF_RICserviceQuery_IEs_tags_101[] = {
7184         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
7185 };
7186 static const asn_TYPE_tag2member_t asn_MAP_RICserviceQuery_IEs_tag2el_101[] = {
7187     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
7188     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
7189     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
7190 };
7191 asn_SEQUENCE_specifics_t asn_SPC_RICserviceQuery_IEs_specs_101 = {
7192         sizeof(struct RICserviceQuery_IEs),
7193         offsetof(struct RICserviceQuery_IEs, _asn_ctx),
7194         asn_MAP_RICserviceQuery_IEs_tag2el_101,
7195         3,      /* Count of tags in the map */
7196         0, 0, 0,        /* Optional elements (not needed) */
7197         -1,     /* First extension addition */
7198 };
7199 asn_TYPE_descriptor_t asn_DEF_RICserviceQuery_IEs = {
7200         "RICserviceQuery-IEs",
7201         "RICserviceQuery-IEs",
7202         &asn_OP_SEQUENCE,
7203         asn_DEF_RICserviceQuery_IEs_tags_101,
7204         sizeof(asn_DEF_RICserviceQuery_IEs_tags_101)
7205                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_101[0]), /* 1 */
7206         asn_DEF_RICserviceQuery_IEs_tags_101,   /* Same as above */
7207         sizeof(asn_DEF_RICserviceQuery_IEs_tags_101)
7208                 /sizeof(asn_DEF_RICserviceQuery_IEs_tags_101[0]), /* 1 */
7209         { 0, 0, SEQUENCE_constraint },
7210         asn_MBR_RICserviceQuery_IEs_101,
7211         3,      /* Elements count */
7212         &asn_SPC_RICserviceQuery_IEs_specs_101  /* Additional specs */
7213 };
7214