src/codec_utils/RRC/PDCP-Config.c

   1 /*
   2  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
   3  * From ASN.1 module "NR-RRC-Definitions"
   4  *      found in "../../../rrc_15.3_asn.asn1"
   5  *      `asn1c -D ./25_02_2022_RRC/ -fcompound-names -fno-include-deps -findirect-choice -gen-PER -no-gen-example`
   6  */
   7
   8 #include "PDCP-Config.h"
   9
  10 /*
  11  * This type is implemented using NativeEnumerated,
  12  * so here we adjust the DEF accordingly.
  13  */
  14 /*
  15  * This type is implemented using NativeEnumerated,
  16  * so here we adjust the DEF accordingly.
  17  */
  18 /*
  19  * This type is implemented using NativeEnumerated,
  20  * so here we adjust the DEF accordingly.
  21  */
  22 /*
  23  * This type is implemented using NativeEnumerated,
  24  * so here we adjust the DEF accordingly.
  25  */
  26 static int
  27 memb_maxCID_constraint_28(const asn_TYPE_descriptor_t *td, const void *sptr,
  28                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  29         long value;
  30
  31         if(!sptr) {
  32                 ASN__CTFAIL(app_key, td, sptr,
  33                         "%s: value not given (%s:%d)",
  34                         td->name, __FILE__, __LINE__);
  35                 return -1;
  36         }
  37
  38         value = *(const long *)sptr;
  39
  40         if((value >= 1 && value <= 16383)) {
  41                 /* Constraint check succeeded */
  42                 return 0;
  43         } else {
  44                 ASN__CTFAIL(app_key, td, sptr,
  45                         "%s: constraint failed (%s:%d)",
  46                         td->name, __FILE__, __LINE__);
  47                 return -1;
  48         }
  49 }
  50
  51 /*
  52  * This type is implemented using NativeEnumerated,
  53  * so here we adjust the DEF accordingly.
  54  */
  55 static int
  56 memb_maxCID_constraint_42(const asn_TYPE_descriptor_t *td, const void *sptr,
  57                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  58         long value;
  59
  60         if(!sptr) {
  61                 ASN__CTFAIL(app_key, td, sptr,
  62                         "%s: value not given (%s:%d)",
  63                         td->name, __FILE__, __LINE__);
  64                 return -1;
  65         }
  66
  67         value = *(const long *)sptr;
  68
  69         if((value >= 1 && value <= 16383)) {
  70                 /* Constraint check succeeded */
  71                 return 0;
  72         } else {
  73                 ASN__CTFAIL(app_key, td, sptr,
  74                         "%s: constraint failed (%s:%d)",
  75                         td->name, __FILE__, __LINE__);
  76                 return -1;
  77         }
  78 }
  79
  80 /*
  81  * This type is implemented using NativeEnumerated,
  82  * so here we adjust the DEF accordingly.
  83  */
  84 /*
  85  * This type is implemented using NativeEnumerated,
  86  * so here we adjust the DEF accordingly.
  87  */
  88 /*
  89  * This type is implemented using NativeEnumerated,
  90  * so here we adjust the DEF accordingly.
  91  */
  92 /*
  93  * This type is implemented using NativeEnumerated,
  94  * so here we adjust the DEF accordingly.
  95  */
  96 /*
  97  * This type is implemented using NativeEnumerated,
  98  * so here we adjust the DEF accordingly.
  99  */
 100 static asn_oer_constraints_t asn_OER_type_discardTimer_constr_3 CC_NOTUSED = {
 101         { 0, 0 },
 102         -1};
 103 static asn_per_constraints_t asn_PER_type_discardTimer_constr_3 CC_NOTUSED = {
 104         { APC_CONSTRAINED,       4,  4,  0,  15 }       /* (0..15) */,
 105         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 106         0, 0    /* No PER value map */
 107 };
 108 static asn_oer_constraints_t asn_OER_type_pdcp_SN_SizeUL_constr_20 CC_NOTUSED = {
 109         { 0, 0 },
 110         -1};
 111 static asn_per_constraints_t asn_PER_type_pdcp_SN_SizeUL_constr_20 CC_NOTUSED = {
 112         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
 113         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 114         0, 0    /* No PER value map */
 115 };
 116 static asn_oer_constraints_t asn_OER_type_pdcp_SN_SizeDL_constr_23 CC_NOTUSED = {
 117         { 0, 0 },
 118         -1};
 119 static asn_per_constraints_t asn_PER_type_pdcp_SN_SizeDL_constr_23 CC_NOTUSED = {
 120         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
 121         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 122         0, 0    /* No PER value map */
 123 };
 124 static asn_oer_constraints_t asn_OER_type_drb_ContinueROHC_constr_40 CC_NOTUSED = {
 125         { 0, 0 },
 126         -1};
 127 static asn_per_constraints_t asn_PER_type_drb_ContinueROHC_constr_40 CC_NOTUSED = {
 128         { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
 129         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 130         0, 0    /* No PER value map */
 131 };
 132 static asn_oer_constraints_t asn_OER_memb_maxCID_constr_29 CC_NOTUSED = {
 133         { 2, 1 }        /* (1..16383) */,
 134         -1};
 135 static asn_per_constraints_t asn_PER_memb_maxCID_constr_29 CC_NOTUSED = {
 136         { APC_CONSTRAINED,       14,  14,  1,  16383 }  /* (1..16383) */,
 137         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 138         0, 0    /* No PER value map */
 139 };
 140 static asn_oer_constraints_t asn_OER_type_drb_ContinueROHC_constr_46 CC_NOTUSED = {
 141         { 0, 0 },
 142         -1};
 143 static asn_per_constraints_t asn_PER_type_drb_ContinueROHC_constr_46 CC_NOTUSED = {
 144         { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
 145         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 146         0, 0    /* No PER value map */
 147 };
 148 static asn_oer_constraints_t asn_OER_memb_maxCID_constr_43 CC_NOTUSED = {
 149         { 2, 1 }        /* (1..16383) */,
 150         -1};
 151 static asn_per_constraints_t asn_PER_memb_maxCID_constr_43 CC_NOTUSED = {
 152         { APC_CONSTRAINED,       14,  14,  1,  16383 }  /* (1..16383) */,
 153         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 154         0, 0    /* No PER value map */
 155 };
 156 static asn_oer_constraints_t asn_OER_type_headerCompression_constr_26 CC_NOTUSED = {
 157         { 0, 0 },
 158         -1};
 159 static asn_per_constraints_t asn_PER_type_headerCompression_constr_26 CC_NOTUSED = {
 160         { APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  2 }    /* (0..2,...) */,
 161         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 162         0, 0    /* No PER value map */
 163 };
 164 static asn_oer_constraints_t asn_OER_type_integrityProtection_constr_49 CC_NOTUSED = {
 165         { 0, 0 },
 166         -1};
 167 static asn_per_constraints_t asn_PER_type_integrityProtection_constr_49 CC_NOTUSED = {
 168         { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
 169         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 170         0, 0    /* No PER value map */
 171 };
 172 static asn_oer_constraints_t asn_OER_type_statusReportRequired_constr_51 CC_NOTUSED = {
 173         { 0, 0 },
 174         -1};
 175 static asn_per_constraints_t asn_PER_type_statusReportRequired_constr_51 CC_NOTUSED = {
 176         { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
 177         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 178         0, 0    /* No PER value map */
 179 };
 180 static asn_oer_constraints_t asn_OER_type_outOfOrderDelivery_constr_53 CC_NOTUSED = {
 181         { 0, 0 },
 182         -1};
 183 static asn_per_constraints_t asn_PER_type_outOfOrderDelivery_constr_53 CC_NOTUSED = {
 184         { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
 185         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 186         0, 0    /* No PER value map */
 187 };
 188 static asn_oer_constraints_t asn_OER_type_t_Reordering_constr_61 CC_NOTUSED = {
 189         { 0, 0 },
 190         -1};
 191 static asn_per_constraints_t asn_PER_type_t_Reordering_constr_61 CC_NOTUSED = {
 192         { APC_CONSTRAINED,       6,  6,  0,  63 }       /* (0..63) */,
 193         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 194         0, 0    /* No PER value map */
 195 };
 196 static asn_oer_constraints_t asn_OER_type_cipheringDisabled_constr_128 CC_NOTUSED = {
 197         { 0, 0 },
 198         -1};
 199 static asn_per_constraints_t asn_PER_type_cipheringDisabled_constr_128 CC_NOTUSED = {
 200         { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
 201         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 202         0, 0    /* No PER value map */
 203 };
 204 static const asn_INTEGER_enum_map_t asn_MAP_discardTimer_value2enum_3[] = {
 205         { 0,    4,      "ms10" },
 206         { 1,    4,      "ms20" },
 207         { 2,    4,      "ms30" },
 208         { 3,    4,      "ms40" },
 209         { 4,    4,      "ms50" },
 210         { 5,    4,      "ms60" },
 211         { 6,    4,      "ms75" },
 212         { 7,    5,      "ms100" },
 213         { 8,    5,      "ms150" },
 214         { 9,    5,      "ms200" },
 215         { 10,   5,      "ms250" },
 216         { 11,   5,      "ms300" },
 217         { 12,   5,      "ms500" },
 218         { 13,   5,      "ms750" },
 219         { 14,   6,      "ms1500" },
 220         { 15,   8,      "infinity" }
 221 };
 222 static const unsigned int asn_MAP_discardTimer_enum2value_3[] = {
 223         15,     /* infinity(15) */
 224         0,      /* ms10(0) */
 225         7,      /* ms100(7) */
 226         8,      /* ms150(8) */
 227         14,     /* ms1500(14) */
 228         1,      /* ms20(1) */
 229         9,      /* ms200(9) */
 230         10,     /* ms250(10) */
 231         2,      /* ms30(2) */
 232         11,     /* ms300(11) */
 233         3,      /* ms40(3) */
 234         4,      /* ms50(4) */
 235         12,     /* ms500(12) */
 236         5,      /* ms60(5) */
 237         6,      /* ms75(6) */
 238         13      /* ms750(13) */
 239 };
 240 static const asn_INTEGER_specifics_t asn_SPC_discardTimer_specs_3 = {
 241         asn_MAP_discardTimer_value2enum_3,      /* "tag" => N; sorted by tag */
 242         asn_MAP_discardTimer_enum2value_3,      /* N => "tag"; sorted by N */
 243         16,     /* Number of elements in the maps */
 244         0,      /* Enumeration is not extensible */
 245         1,      /* Strict enumeration */
 246         0,      /* Native long size */
 247         0
 248 };
 249 static const ber_tlv_tag_t asn_DEF_discardTimer_tags_3[] = {
 250         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 251         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 252 };
 253 static /* Use -fall-defs-global to expose */
 254 asn_TYPE_descriptor_t asn_DEF_discardTimer_3 = {
 255         "discardTimer",
 256         "discardTimer",
 257         &asn_OP_NativeEnumerated,
 258         asn_DEF_discardTimer_tags_3,
 259         sizeof(asn_DEF_discardTimer_tags_3)
 260                 /sizeof(asn_DEF_discardTimer_tags_3[0]) - 1, /* 1 */
 261         asn_DEF_discardTimer_tags_3,    /* Same as above */
 262         sizeof(asn_DEF_discardTimer_tags_3)
 263                 /sizeof(asn_DEF_discardTimer_tags_3[0]), /* 2 */
 264         { &asn_OER_type_discardTimer_constr_3, &asn_PER_type_discardTimer_constr_3, NativeEnumerated_constraint },
 265         0, 0,   /* Defined elsewhere */
 266         &asn_SPC_discardTimer_specs_3   /* Additional specs */
 267 };
 268
 269 static const asn_INTEGER_enum_map_t asn_MAP_pdcp_SN_SizeUL_value2enum_20[] = {
 270         { 0,    9,      "len12bits" },
 271         { 1,    9,      "len18bits" }
 272 };
 273 static const unsigned int asn_MAP_pdcp_SN_SizeUL_enum2value_20[] = {
 274         0,      /* len12bits(0) */
 275         1       /* len18bits(1) */
 276 };
 277 static const asn_INTEGER_specifics_t asn_SPC_pdcp_SN_SizeUL_specs_20 = {
 278         asn_MAP_pdcp_SN_SizeUL_value2enum_20,   /* "tag" => N; sorted by tag */
 279         asn_MAP_pdcp_SN_SizeUL_enum2value_20,   /* N => "tag"; sorted by N */
 280         2,      /* Number of elements in the maps */
 281         0,      /* Enumeration is not extensible */
 282         1,      /* Strict enumeration */
 283         0,      /* Native long size */
 284         0
 285 };
 286 static const ber_tlv_tag_t asn_DEF_pdcp_SN_SizeUL_tags_20[] = {
 287         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 288         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 289 };
 290 static /* Use -fall-defs-global to expose */
 291 asn_TYPE_descriptor_t asn_DEF_pdcp_SN_SizeUL_20 = {
 292         "pdcp-SN-SizeUL",
 293         "pdcp-SN-SizeUL",
 294         &asn_OP_NativeEnumerated,
 295         asn_DEF_pdcp_SN_SizeUL_tags_20,
 296         sizeof(asn_DEF_pdcp_SN_SizeUL_tags_20)
 297                 /sizeof(asn_DEF_pdcp_SN_SizeUL_tags_20[0]) - 1, /* 1 */
 298         asn_DEF_pdcp_SN_SizeUL_tags_20, /* Same as above */
 299         sizeof(asn_DEF_pdcp_SN_SizeUL_tags_20)
 300                 /sizeof(asn_DEF_pdcp_SN_SizeUL_tags_20[0]), /* 2 */
 301         { &asn_OER_type_pdcp_SN_SizeUL_constr_20, &asn_PER_type_pdcp_SN_SizeUL_constr_20, NativeEnumerated_constraint },
 302         0, 0,   /* Defined elsewhere */
 303         &asn_SPC_pdcp_SN_SizeUL_specs_20        /* Additional specs */
 304 };
 305
 306 static const asn_INTEGER_enum_map_t asn_MAP_pdcp_SN_SizeDL_value2enum_23[] = {
 307         { 0,    9,      "len12bits" },
 308         { 1,    9,      "len18bits" }
 309 };
 310 static const unsigned int asn_MAP_pdcp_SN_SizeDL_enum2value_23[] = {
 311         0,      /* len12bits(0) */
 312         1       /* len18bits(1) */
 313 };
 314 static const asn_INTEGER_specifics_t asn_SPC_pdcp_SN_SizeDL_specs_23 = {
 315         asn_MAP_pdcp_SN_SizeDL_value2enum_23,   /* "tag" => N; sorted by tag */
 316         asn_MAP_pdcp_SN_SizeDL_enum2value_23,   /* N => "tag"; sorted by N */
 317         2,      /* Number of elements in the maps */
 318         0,      /* Enumeration is not extensible */
 319         1,      /* Strict enumeration */
 320         0,      /* Native long size */
 321         0
 322 };
 323 static const ber_tlv_tag_t asn_DEF_pdcp_SN_SizeDL_tags_23[] = {
 324         (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 325         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 326 };
 327 static /* Use -fall-defs-global to expose */
 328 asn_TYPE_descriptor_t asn_DEF_pdcp_SN_SizeDL_23 = {
 329         "pdcp-SN-SizeDL",
 330         "pdcp-SN-SizeDL",
 331         &asn_OP_NativeEnumerated,
 332         asn_DEF_pdcp_SN_SizeDL_tags_23,
 333         sizeof(asn_DEF_pdcp_SN_SizeDL_tags_23)
 334                 /sizeof(asn_DEF_pdcp_SN_SizeDL_tags_23[0]) - 1, /* 1 */
 335         asn_DEF_pdcp_SN_SizeDL_tags_23, /* Same as above */
 336         sizeof(asn_DEF_pdcp_SN_SizeDL_tags_23)
 337                 /sizeof(asn_DEF_pdcp_SN_SizeDL_tags_23[0]), /* 2 */
 338         { &asn_OER_type_pdcp_SN_SizeDL_constr_23, &asn_PER_type_pdcp_SN_SizeDL_constr_23, NativeEnumerated_constraint },
 339         0, 0,   /* Defined elsewhere */
 340         &asn_SPC_pdcp_SN_SizeDL_specs_23        /* Additional specs */
 341 };
 342
 343 static int asn_DFL_29_cmp_15(const void *sptr) {
 344         const long *st = sptr;
 345
 346         if(!st) {
 347                 return -1; /* No value is not a default value */
 348         }
 349
 350         /* Test default value 15 */
 351         return (*st != 15);
 352 }
 353 static int asn_DFL_29_set_15(void **sptr) {
 354         long *st = *sptr;
 355
 356         if(!st) {
 357                 st = (*sptr = CALLOC(1, sizeof(*st)));
 358                 if(!st) return -1;
 359         }
 360
 361         /* Install default value 15 */
 362         *st = 15;
 363         return 0;
 364 }
 365 static asn_TYPE_member_t asn_MBR_profiles_30[] = {
 366         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0001),
 367                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 368                 -1,     /* IMPLICIT tag at current level */
 369                 &asn_DEF_BOOLEAN,
 370                 0,
 371                 { 0, 0, 0 },
 372                 0, 0, /* No default value */
 373                 "profile0x0001"
 374                 },
 375         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0002),
 376                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 377                 -1,     /* IMPLICIT tag at current level */
 378                 &asn_DEF_BOOLEAN,
 379                 0,
 380                 { 0, 0, 0 },
 381                 0, 0, /* No default value */
 382                 "profile0x0002"
 383                 },
 384         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0003),
 385                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 386                 -1,     /* IMPLICIT tag at current level */
 387                 &asn_DEF_BOOLEAN,
 388                 0,
 389                 { 0, 0, 0 },
 390                 0, 0, /* No default value */
 391                 "profile0x0003"
 392                 },
 393         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0004),
 394                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 395                 -1,     /* IMPLICIT tag at current level */
 396                 &asn_DEF_BOOLEAN,
 397                 0,
 398                 { 0, 0, 0 },
 399                 0, 0, /* No default value */
 400                 "profile0x0004"
 401                 },
 402         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0006),
 403                 (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 404                 -1,     /* IMPLICIT tag at current level */
 405                 &asn_DEF_BOOLEAN,
 406                 0,
 407                 { 0, 0, 0 },
 408                 0, 0, /* No default value */
 409                 "profile0x0006"
 410                 },
 411         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0101),
 412                 (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 413                 -1,     /* IMPLICIT tag at current level */
 414                 &asn_DEF_BOOLEAN,
 415                 0,
 416                 { 0, 0, 0 },
 417                 0, 0, /* No default value */
 418                 "profile0x0101"
 419                 },
 420         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0102),
 421                 (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 422                 -1,     /* IMPLICIT tag at current level */
 423                 &asn_DEF_BOOLEAN,
 424                 0,
 425                 { 0, 0, 0 },
 426                 0, 0, /* No default value */
 427                 "profile0x0102"
 428                 },
 429         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0103),
 430                 (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
 431                 -1,     /* IMPLICIT tag at current level */
 432                 &asn_DEF_BOOLEAN,
 433                 0,
 434                 { 0, 0, 0 },
 435                 0, 0, /* No default value */
 436                 "profile0x0103"
 437                 },
 438         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, profile0x0104),
 439                 (ASN_TAG_CLASS_CONTEXT | (8 << 2)),
 440                 -1,     /* IMPLICIT tag at current level */
 441                 &asn_DEF_BOOLEAN,
 442                 0,
 443                 { 0, 0, 0 },
 444                 0, 0, /* No default value */
 445                 "profile0x0104"
 446                 },
 447 };
 448 static const ber_tlv_tag_t asn_DEF_profiles_tags_30[] = {
 449         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 450         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 451 };
 452 static const asn_TYPE_tag2member_t asn_MAP_profiles_tag2el_30[] = {
 453     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* profile0x0001 */
 454     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* profile0x0002 */
 455     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* profile0x0003 */
 456     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* profile0x0004 */
 457     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* profile0x0006 */
 458     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* profile0x0101 */
 459     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* profile0x0102 */
 460     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* profile0x0103 */
 461     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 } /* profile0x0104 */
 462 };
 463 static asn_SEQUENCE_specifics_t asn_SPC_profiles_specs_30 = {
 464         sizeof(struct PDCP_Config__drb__headerCompression__rohc__profiles),
 465         offsetof(struct PDCP_Config__drb__headerCompression__rohc__profiles, _asn_ctx),
 466         asn_MAP_profiles_tag2el_30,
 467         9,      /* Count of tags in the map */
 468         0, 0, 0,        /* Optional elements (not needed) */
 469         -1,     /* First extension addition */
 470 };
 471 static /* Use -fall-defs-global to expose */
 472 asn_TYPE_descriptor_t asn_DEF_profiles_30 = {
 473         "profiles",
 474         "profiles",
 475         &asn_OP_SEQUENCE,
 476         asn_DEF_profiles_tags_30,
 477         sizeof(asn_DEF_profiles_tags_30)
 478                 /sizeof(asn_DEF_profiles_tags_30[0]) - 1, /* 1 */
 479         asn_DEF_profiles_tags_30,       /* Same as above */
 480         sizeof(asn_DEF_profiles_tags_30)
 481                 /sizeof(asn_DEF_profiles_tags_30[0]), /* 2 */
 482         { 0, 0, SEQUENCE_constraint },
 483         asn_MBR_profiles_30,
 484         9,      /* Elements count */
 485         &asn_SPC_profiles_specs_30      /* Additional specs */
 486 };
 487
 488 static const asn_INTEGER_enum_map_t asn_MAP_drb_ContinueROHC_value2enum_40[] = {
 489         { 0,    4,      "true" }
 490 };
 491 static const unsigned int asn_MAP_drb_ContinueROHC_enum2value_40[] = {
 492         0       /* true(0) */
 493 };
 494 static const asn_INTEGER_specifics_t asn_SPC_drb_ContinueROHC_specs_40 = {
 495         asn_MAP_drb_ContinueROHC_value2enum_40, /* "tag" => N; sorted by tag */
 496         asn_MAP_drb_ContinueROHC_enum2value_40, /* N => "tag"; sorted by N */
 497         1,      /* Number of elements in the maps */
 498         0,      /* Enumeration is not extensible */
 499         1,      /* Strict enumeration */
 500         0,      /* Native long size */
 501         0
 502 };
 503 static const ber_tlv_tag_t asn_DEF_drb_ContinueROHC_tags_40[] = {
 504         (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 505         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 506 };
 507 static /* Use -fall-defs-global to expose */
 508 asn_TYPE_descriptor_t asn_DEF_drb_ContinueROHC_40 = {
 509         "drb-ContinueROHC",
 510         "drb-ContinueROHC",
 511         &asn_OP_NativeEnumerated,
 512         asn_DEF_drb_ContinueROHC_tags_40,
 513         sizeof(asn_DEF_drb_ContinueROHC_tags_40)
 514                 /sizeof(asn_DEF_drb_ContinueROHC_tags_40[0]) - 1, /* 1 */
 515         asn_DEF_drb_ContinueROHC_tags_40,       /* Same as above */
 516         sizeof(asn_DEF_drb_ContinueROHC_tags_40)
 517                 /sizeof(asn_DEF_drb_ContinueROHC_tags_40[0]), /* 2 */
 518         { &asn_OER_type_drb_ContinueROHC_constr_40, &asn_PER_type_drb_ContinueROHC_constr_40, NativeEnumerated_constraint },
 519         0, 0,   /* Defined elsewhere */
 520         &asn_SPC_drb_ContinueROHC_specs_40      /* Additional specs */
 521 };
 522
 523 static asn_TYPE_member_t asn_MBR_rohc_28[] = {
 524         { ATF_POINTER, 1, offsetof(struct PDCP_Config__drb__headerCompression__rohc, maxCID),
 525                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 526                 -1,     /* IMPLICIT tag at current level */
 527                 &asn_DEF_NativeInteger,
 528                 0,
 529                 { &asn_OER_memb_maxCID_constr_29, &asn_PER_memb_maxCID_constr_29,  memb_maxCID_constraint_28 },
 530                 &asn_DFL_29_cmp_15,     /* Compare DEFAULT 15 */
 531                 &asn_DFL_29_set_15,     /* Set DEFAULT 15 */
 532                 "maxCID"
 533                 },
 534         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__rohc, profiles),
 535                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 536                 0,
 537                 &asn_DEF_profiles_30,
 538                 0,
 539                 { 0, 0, 0 },
 540                 0, 0, /* No default value */
 541                 "profiles"
 542                 },
 543         { ATF_POINTER, 1, offsetof(struct PDCP_Config__drb__headerCompression__rohc, drb_ContinueROHC),
 544                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 545                 -1,     /* IMPLICIT tag at current level */
 546                 &asn_DEF_drb_ContinueROHC_40,
 547                 0,
 548                 { 0, 0, 0 },
 549                 0, 0, /* No default value */
 550                 "drb-ContinueROHC"
 551                 },
 552 };
 553 static const int asn_MAP_rohc_oms_28[] = { 0, 2 };
 554 static const ber_tlv_tag_t asn_DEF_rohc_tags_28[] = {
 555         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 556         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 557 };
 558 static const asn_TYPE_tag2member_t asn_MAP_rohc_tag2el_28[] = {
 559     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* maxCID */
 560     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* profiles */
 561     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* drb-ContinueROHC */
 562 };
 563 static asn_SEQUENCE_specifics_t asn_SPC_rohc_specs_28 = {
 564         sizeof(struct PDCP_Config__drb__headerCompression__rohc),
 565         offsetof(struct PDCP_Config__drb__headerCompression__rohc, _asn_ctx),
 566         asn_MAP_rohc_tag2el_28,
 567         3,      /* Count of tags in the map */
 568         asn_MAP_rohc_oms_28,    /* Optional members */
 569         2, 0,   /* Root/Additions */
 570         -1,     /* First extension addition */
 571 };
 572 static /* Use -fall-defs-global to expose */
 573 asn_TYPE_descriptor_t asn_DEF_rohc_28 = {
 574         "rohc",
 575         "rohc",
 576         &asn_OP_SEQUENCE,
 577         asn_DEF_rohc_tags_28,
 578         sizeof(asn_DEF_rohc_tags_28)
 579                 /sizeof(asn_DEF_rohc_tags_28[0]) - 1, /* 1 */
 580         asn_DEF_rohc_tags_28,   /* Same as above */
 581         sizeof(asn_DEF_rohc_tags_28)
 582                 /sizeof(asn_DEF_rohc_tags_28[0]), /* 2 */
 583         { 0, 0, SEQUENCE_constraint },
 584         asn_MBR_rohc_28,
 585         3,      /* Elements count */
 586         &asn_SPC_rohc_specs_28  /* Additional specs */
 587 };
 588
 589 static int asn_DFL_43_cmp_15(const void *sptr) {
 590         const long *st = sptr;
 591
 592         if(!st) {
 593                 return -1; /* No value is not a default value */
 594         }
 595
 596         /* Test default value 15 */
 597         return (*st != 15);
 598 }
 599 static int asn_DFL_43_set_15(void **sptr) {
 600         long *st = *sptr;
 601
 602         if(!st) {
 603                 st = (*sptr = CALLOC(1, sizeof(*st)));
 604                 if(!st) return -1;
 605         }
 606
 607         /* Install default value 15 */
 608         *st = 15;
 609         return 0;
 610 }
 611 static asn_TYPE_member_t asn_MBR_profiles_44[] = {
 612         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC__profiles, profile0x0006),
 613                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 614                 -1,     /* IMPLICIT tag at current level */
 615                 &asn_DEF_BOOLEAN,
 616                 0,
 617                 { 0, 0, 0 },
 618                 0, 0, /* No default value */
 619                 "profile0x0006"
 620                 },
 621 };
 622 static const ber_tlv_tag_t asn_DEF_profiles_tags_44[] = {
 623         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 624         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 625 };
 626 static const asn_TYPE_tag2member_t asn_MAP_profiles_tag2el_44[] = {
 627     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* profile0x0006 */
 628 };
 629 static asn_SEQUENCE_specifics_t asn_SPC_profiles_specs_44 = {
 630         sizeof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC__profiles),
 631         offsetof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC__profiles, _asn_ctx),
 632         asn_MAP_profiles_tag2el_44,
 633         1,      /* Count of tags in the map */
 634         0, 0, 0,        /* Optional elements (not needed) */
 635         -1,     /* First extension addition */
 636 };
 637 static /* Use -fall-defs-global to expose */
 638 asn_TYPE_descriptor_t asn_DEF_profiles_44 = {
 639         "profiles",
 640         "profiles",
 641         &asn_OP_SEQUENCE,
 642         asn_DEF_profiles_tags_44,
 643         sizeof(asn_DEF_profiles_tags_44)
 644                 /sizeof(asn_DEF_profiles_tags_44[0]) - 1, /* 1 */
 645         asn_DEF_profiles_tags_44,       /* Same as above */
 646         sizeof(asn_DEF_profiles_tags_44)
 647                 /sizeof(asn_DEF_profiles_tags_44[0]), /* 2 */
 648         { 0, 0, SEQUENCE_constraint },
 649         asn_MBR_profiles_44,
 650         1,      /* Elements count */
 651         &asn_SPC_profiles_specs_44      /* Additional specs */
 652 };
 653
 654 static const asn_INTEGER_enum_map_t asn_MAP_drb_ContinueROHC_value2enum_46[] = {
 655         { 0,    4,      "true" }
 656 };
 657 static const unsigned int asn_MAP_drb_ContinueROHC_enum2value_46[] = {
 658         0       /* true(0) */
 659 };
 660 static const asn_INTEGER_specifics_t asn_SPC_drb_ContinueROHC_specs_46 = {
 661         asn_MAP_drb_ContinueROHC_value2enum_46, /* "tag" => N; sorted by tag */
 662         asn_MAP_drb_ContinueROHC_enum2value_46, /* N => "tag"; sorted by N */
 663         1,      /* Number of elements in the maps */
 664         0,      /* Enumeration is not extensible */
 665         1,      /* Strict enumeration */
 666         0,      /* Native long size */
 667         0
 668 };
 669 static const ber_tlv_tag_t asn_DEF_drb_ContinueROHC_tags_46[] = {
 670         (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 671         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 672 };
 673 static /* Use -fall-defs-global to expose */
 674 asn_TYPE_descriptor_t asn_DEF_drb_ContinueROHC_46 = {
 675         "drb-ContinueROHC",
 676         "drb-ContinueROHC",
 677         &asn_OP_NativeEnumerated,
 678         asn_DEF_drb_ContinueROHC_tags_46,
 679         sizeof(asn_DEF_drb_ContinueROHC_tags_46)
 680                 /sizeof(asn_DEF_drb_ContinueROHC_tags_46[0]) - 1, /* 1 */
 681         asn_DEF_drb_ContinueROHC_tags_46,       /* Same as above */
 682         sizeof(asn_DEF_drb_ContinueROHC_tags_46)
 683                 /sizeof(asn_DEF_drb_ContinueROHC_tags_46[0]), /* 2 */
 684         { &asn_OER_type_drb_ContinueROHC_constr_46, &asn_PER_type_drb_ContinueROHC_constr_46, NativeEnumerated_constraint },
 685         0, 0,   /* Defined elsewhere */
 686         &asn_SPC_drb_ContinueROHC_specs_46      /* Additional specs */
 687 };
 688
 689 static asn_TYPE_member_t asn_MBR_uplinkOnlyROHC_42[] = {
 690         { ATF_POINTER, 1, offsetof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC, maxCID),
 691                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 692                 -1,     /* IMPLICIT tag at current level */
 693                 &asn_DEF_NativeInteger,
 694                 0,
 695                 { &asn_OER_memb_maxCID_constr_43, &asn_PER_memb_maxCID_constr_43,  memb_maxCID_constraint_42 },
 696                 &asn_DFL_43_cmp_15,     /* Compare DEFAULT 15 */
 697                 &asn_DFL_43_set_15,     /* Set DEFAULT 15 */
 698                 "maxCID"
 699                 },
 700         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC, profiles),
 701                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 702                 0,
 703                 &asn_DEF_profiles_44,
 704                 0,
 705                 { 0, 0, 0 },
 706                 0, 0, /* No default value */
 707                 "profiles"
 708                 },
 709         { ATF_POINTER, 1, offsetof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC, drb_ContinueROHC),
 710                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 711                 -1,     /* IMPLICIT tag at current level */
 712                 &asn_DEF_drb_ContinueROHC_46,
 713                 0,
 714                 { 0, 0, 0 },
 715                 0, 0, /* No default value */
 716                 "drb-ContinueROHC"
 717                 },
 718 };
 719 static const int asn_MAP_uplinkOnlyROHC_oms_42[] = { 0, 2 };
 720 static const ber_tlv_tag_t asn_DEF_uplinkOnlyROHC_tags_42[] = {
 721         (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 722         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 723 };
 724 static const asn_TYPE_tag2member_t asn_MAP_uplinkOnlyROHC_tag2el_42[] = {
 725     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* maxCID */
 726     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* profiles */
 727     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* drb-ContinueROHC */
 728 };
 729 static asn_SEQUENCE_specifics_t asn_SPC_uplinkOnlyROHC_specs_42 = {
 730         sizeof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC),
 731         offsetof(struct PDCP_Config__drb__headerCompression__uplinkOnlyROHC, _asn_ctx),
 732         asn_MAP_uplinkOnlyROHC_tag2el_42,
 733         3,      /* Count of tags in the map */
 734         asn_MAP_uplinkOnlyROHC_oms_42,  /* Optional members */
 735         2, 0,   /* Root/Additions */
 736         -1,     /* First extension addition */
 737 };
 738 static /* Use -fall-defs-global to expose */
 739 asn_TYPE_descriptor_t asn_DEF_uplinkOnlyROHC_42 = {
 740         "uplinkOnlyROHC",
 741         "uplinkOnlyROHC",
 742         &asn_OP_SEQUENCE,
 743         asn_DEF_uplinkOnlyROHC_tags_42,
 744         sizeof(asn_DEF_uplinkOnlyROHC_tags_42)
 745                 /sizeof(asn_DEF_uplinkOnlyROHC_tags_42[0]) - 1, /* 1 */
 746         asn_DEF_uplinkOnlyROHC_tags_42, /* Same as above */
 747         sizeof(asn_DEF_uplinkOnlyROHC_tags_42)
 748                 /sizeof(asn_DEF_uplinkOnlyROHC_tags_42[0]), /* 2 */
 749         { 0, 0, SEQUENCE_constraint },
 750         asn_MBR_uplinkOnlyROHC_42,
 751         3,      /* Elements count */
 752         &asn_SPC_uplinkOnlyROHC_specs_42        /* Additional specs */
 753 };
 754
 755 static asn_TYPE_member_t asn_MBR_headerCompression_26[] = {
 756         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb__headerCompression, choice.notUsed),
 757                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 758                 -1,     /* IMPLICIT tag at current level */
 759                 &asn_DEF_NULL,
 760                 0,
 761                 { 0, 0, 0 },
 762                 0, 0, /* No default value */
 763                 "notUsed"
 764                 },
 765         { ATF_POINTER, 0, offsetof(struct PDCP_Config__drb__headerCompression, choice.rohc),
 766                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 767                 0,
 768                 &asn_DEF_rohc_28,
 769                 0,
 770                 { 0, 0, 0 },
 771                 0, 0, /* No default value */
 772                 "rohc"
 773                 },
 774         { ATF_POINTER, 0, offsetof(struct PDCP_Config__drb__headerCompression, choice.uplinkOnlyROHC),
 775                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 776                 0,
 777                 &asn_DEF_uplinkOnlyROHC_42,
 778                 0,
 779                 { 0, 0, 0 },
 780                 0, 0, /* No default value */
 781                 "uplinkOnlyROHC"
 782                 },
 783 };
 784 static const asn_TYPE_tag2member_t asn_MAP_headerCompression_tag2el_26[] = {
 785     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* notUsed */
 786     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* rohc */
 787     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* uplinkOnlyROHC */
 788 };
 789 static asn_CHOICE_specifics_t asn_SPC_headerCompression_specs_26 = {
 790         sizeof(struct PDCP_Config__drb__headerCompression),
 791         offsetof(struct PDCP_Config__drb__headerCompression, _asn_ctx),
 792         offsetof(struct PDCP_Config__drb__headerCompression, present),
 793         sizeof(((struct PDCP_Config__drb__headerCompression *)0)->present),
 794         asn_MAP_headerCompression_tag2el_26,
 795         3,      /* Count of tags in the map */
 796         0, 0,
 797         3       /* Extensions start */
 798 };
 799 static /* Use -fall-defs-global to expose */
 800 asn_TYPE_descriptor_t asn_DEF_headerCompression_26 = {
 801         "headerCompression",
 802         "headerCompression",
 803         &asn_OP_CHOICE,
 804         0,      /* No effective tags (pointer) */
 805         0,      /* No effective tags (count) */
 806         0,      /* No tags (pointer) */
 807         0,      /* No tags (count) */
 808         { &asn_OER_type_headerCompression_constr_26, &asn_PER_type_headerCompression_constr_26, CHOICE_constraint },
 809         asn_MBR_headerCompression_26,
 810         3,      /* Elements count */
 811         &asn_SPC_headerCompression_specs_26     /* Additional specs */
 812 };
 813
 814 static const asn_INTEGER_enum_map_t asn_MAP_integrityProtection_value2enum_49[] = {
 815         { 0,    7,      "enabled" }
 816 };
 817 static const unsigned int asn_MAP_integrityProtection_enum2value_49[] = {
 818         0       /* enabled(0) */
 819 };
 820 static const asn_INTEGER_specifics_t asn_SPC_integrityProtection_specs_49 = {
 821         asn_MAP_integrityProtection_value2enum_49,      /* "tag" => N; sorted by tag */
 822         asn_MAP_integrityProtection_enum2value_49,      /* N => "tag"; sorted by N */
 823         1,      /* Number of elements in the maps */
 824         0,      /* Enumeration is not extensible */
 825         1,      /* Strict enumeration */
 826         0,      /* Native long size */
 827         0
 828 };
 829 static const ber_tlv_tag_t asn_DEF_integrityProtection_tags_49[] = {
 830         (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 831         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 832 };
 833 static /* Use -fall-defs-global to expose */
 834 asn_TYPE_descriptor_t asn_DEF_integrityProtection_49 = {
 835         "integrityProtection",
 836         "integrityProtection",
 837         &asn_OP_NativeEnumerated,
 838         asn_DEF_integrityProtection_tags_49,
 839         sizeof(asn_DEF_integrityProtection_tags_49)
 840                 /sizeof(asn_DEF_integrityProtection_tags_49[0]) - 1, /* 1 */
 841         asn_DEF_integrityProtection_tags_49,    /* Same as above */
 842         sizeof(asn_DEF_integrityProtection_tags_49)
 843                 /sizeof(asn_DEF_integrityProtection_tags_49[0]), /* 2 */
 844         { &asn_OER_type_integrityProtection_constr_49, &asn_PER_type_integrityProtection_constr_49, NativeEnumerated_constraint },
 845         0, 0,   /* Defined elsewhere */
 846         &asn_SPC_integrityProtection_specs_49   /* Additional specs */
 847 };
 848
 849 static const asn_INTEGER_enum_map_t asn_MAP_statusReportRequired_value2enum_51[] = {
 850         { 0,    4,      "true" }
 851 };
 852 static const unsigned int asn_MAP_statusReportRequired_enum2value_51[] = {
 853         0       /* true(0) */
 854 };
 855 static const asn_INTEGER_specifics_t asn_SPC_statusReportRequired_specs_51 = {
 856         asn_MAP_statusReportRequired_value2enum_51,     /* "tag" => N; sorted by tag */
 857         asn_MAP_statusReportRequired_enum2value_51,     /* N => "tag"; sorted by N */
 858         1,      /* Number of elements in the maps */
 859         0,      /* Enumeration is not extensible */
 860         1,      /* Strict enumeration */
 861         0,      /* Native long size */
 862         0
 863 };
 864 static const ber_tlv_tag_t asn_DEF_statusReportRequired_tags_51[] = {
 865         (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 866         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 867 };
 868 static /* Use -fall-defs-global to expose */
 869 asn_TYPE_descriptor_t asn_DEF_statusReportRequired_51 = {
 870         "statusReportRequired",
 871         "statusReportRequired",
 872         &asn_OP_NativeEnumerated,
 873         asn_DEF_statusReportRequired_tags_51,
 874         sizeof(asn_DEF_statusReportRequired_tags_51)
 875                 /sizeof(asn_DEF_statusReportRequired_tags_51[0]) - 1, /* 1 */
 876         asn_DEF_statusReportRequired_tags_51,   /* Same as above */
 877         sizeof(asn_DEF_statusReportRequired_tags_51)
 878                 /sizeof(asn_DEF_statusReportRequired_tags_51[0]), /* 2 */
 879         { &asn_OER_type_statusReportRequired_constr_51, &asn_PER_type_statusReportRequired_constr_51, NativeEnumerated_constraint },
 880         0, 0,   /* Defined elsewhere */
 881         &asn_SPC_statusReportRequired_specs_51  /* Additional specs */
 882 };
 883
 884 static const asn_INTEGER_enum_map_t asn_MAP_outOfOrderDelivery_value2enum_53[] = {
 885         { 0,    4,      "true" }
 886 };
 887 static const unsigned int asn_MAP_outOfOrderDelivery_enum2value_53[] = {
 888         0       /* true(0) */
 889 };
 890 static const asn_INTEGER_specifics_t asn_SPC_outOfOrderDelivery_specs_53 = {
 891         asn_MAP_outOfOrderDelivery_value2enum_53,       /* "tag" => N; sorted by tag */
 892         asn_MAP_outOfOrderDelivery_enum2value_53,       /* N => "tag"; sorted by N */
 893         1,      /* Number of elements in the maps */
 894         0,      /* Enumeration is not extensible */
 895         1,      /* Strict enumeration */
 896         0,      /* Native long size */
 897         0
 898 };
 899 static const ber_tlv_tag_t asn_DEF_outOfOrderDelivery_tags_53[] = {
 900         (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 901         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 902 };
 903 static /* Use -fall-defs-global to expose */
 904 asn_TYPE_descriptor_t asn_DEF_outOfOrderDelivery_53 = {
 905         "outOfOrderDelivery",
 906         "outOfOrderDelivery",
 907         &asn_OP_NativeEnumerated,
 908         asn_DEF_outOfOrderDelivery_tags_53,
 909         sizeof(asn_DEF_outOfOrderDelivery_tags_53)
 910                 /sizeof(asn_DEF_outOfOrderDelivery_tags_53[0]) - 1, /* 1 */
 911         asn_DEF_outOfOrderDelivery_tags_53,     /* Same as above */
 912         sizeof(asn_DEF_outOfOrderDelivery_tags_53)
 913                 /sizeof(asn_DEF_outOfOrderDelivery_tags_53[0]), /* 2 */
 914         { &asn_OER_type_outOfOrderDelivery_constr_53, &asn_PER_type_outOfOrderDelivery_constr_53, NativeEnumerated_constraint },
 915         0, 0,   /* Defined elsewhere */
 916         &asn_SPC_outOfOrderDelivery_specs_53    /* Additional specs */
 917 };
 918
 919 static asn_TYPE_member_t asn_MBR_drb_2[] = {
 920         { ATF_POINTER, 3, offsetof(struct PDCP_Config__drb, discardTimer),
 921                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 922                 -1,     /* IMPLICIT tag at current level */
 923                 &asn_DEF_discardTimer_3,
 924                 0,
 925                 { 0, 0, 0 },
 926                 0, 0, /* No default value */
 927                 "discardTimer"
 928                 },
 929         { ATF_POINTER, 2, offsetof(struct PDCP_Config__drb, pdcp_SN_SizeUL),
 930                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 931                 -1,     /* IMPLICIT tag at current level */
 932                 &asn_DEF_pdcp_SN_SizeUL_20,
 933                 0,
 934                 { 0, 0, 0 },
 935                 0, 0, /* No default value */
 936                 "pdcp-SN-SizeUL"
 937                 },
 938         { ATF_POINTER, 1, offsetof(struct PDCP_Config__drb, pdcp_SN_SizeDL),
 939                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 940                 -1,     /* IMPLICIT tag at current level */
 941                 &asn_DEF_pdcp_SN_SizeDL_23,
 942                 0,
 943                 { 0, 0, 0 },
 944                 0, 0, /* No default value */
 945                 "pdcp-SN-SizeDL"
 946                 },
 947         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__drb, headerCompression),
 948                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 949                 +1,     /* EXPLICIT tag at current level */
 950                 &asn_DEF_headerCompression_26,
 951                 0,
 952                 { 0, 0, 0 },
 953                 0, 0, /* No default value */
 954                 "headerCompression"
 955                 },
 956         { ATF_POINTER, 3, offsetof(struct PDCP_Config__drb, integrityProtection),
 957                 (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 958                 -1,     /* IMPLICIT tag at current level */
 959                 &asn_DEF_integrityProtection_49,
 960                 0,
 961                 { 0, 0, 0 },
 962                 0, 0, /* No default value */
 963                 "integrityProtection"
 964                 },
 965         { ATF_POINTER, 2, offsetof(struct PDCP_Config__drb, statusReportRequired),
 966                 (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 967                 -1,     /* IMPLICIT tag at current level */
 968                 &asn_DEF_statusReportRequired_51,
 969                 0,
 970                 { 0, 0, 0 },
 971                 0, 0, /* No default value */
 972                 "statusReportRequired"
 973                 },
 974         { ATF_POINTER, 1, offsetof(struct PDCP_Config__drb, outOfOrderDelivery),
 975                 (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 976                 -1,     /* IMPLICIT tag at current level */
 977                 &asn_DEF_outOfOrderDelivery_53,
 978                 0,
 979                 { 0, 0, 0 },
 980                 0, 0, /* No default value */
 981                 "outOfOrderDelivery"
 982                 },
 983 };
 984 static const int asn_MAP_drb_oms_2[] = { 0, 1, 2, 4, 5, 6 };
 985 static const ber_tlv_tag_t asn_DEF_drb_tags_2[] = {
 986         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 987         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 988 };
 989 static const asn_TYPE_tag2member_t asn_MAP_drb_tag2el_2[] = {
 990     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* discardTimer */
 991     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* pdcp-SN-SizeUL */
 992     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* pdcp-SN-SizeDL */
 993     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* headerCompression */
 994     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* integrityProtection */
 995     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* statusReportRequired */
 996     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 } /* outOfOrderDelivery */
 997 };
 998 static asn_SEQUENCE_specifics_t asn_SPC_drb_specs_2 = {
 999         sizeof(struct PDCP_Config__drb),
1000         offsetof(struct PDCP_Config__drb, _asn_ctx),
1001         asn_MAP_drb_tag2el_2,
1002         7,      /* Count of tags in the map */
1003         asn_MAP_drb_oms_2,      /* Optional members */
1004         6, 0,   /* Root/Additions */
1005         -1,     /* First extension addition */
1006 };
1007 static /* Use -fall-defs-global to expose */
1008 asn_TYPE_descriptor_t asn_DEF_drb_2 = {
1009         "drb",
1010         "drb",
1011         &asn_OP_SEQUENCE,
1012         asn_DEF_drb_tags_2,
1013         sizeof(asn_DEF_drb_tags_2)
1014                 /sizeof(asn_DEF_drb_tags_2[0]) - 1, /* 1 */
1015         asn_DEF_drb_tags_2,     /* Same as above */
1016         sizeof(asn_DEF_drb_tags_2)
1017                 /sizeof(asn_DEF_drb_tags_2[0]), /* 2 */
1018         { 0, 0, SEQUENCE_constraint },
1019         asn_MBR_drb_2,
1020         7,      /* Elements count */
1021         &asn_SPC_drb_specs_2    /* Additional specs */
1022 };
1023
1024 static asn_TYPE_member_t asn_MBR_primaryPath_56[] = {
1025         { ATF_POINTER, 2, offsetof(struct PDCP_Config__moreThanOneRLC__primaryPath, cellGroup),
1026                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1027                 -1,     /* IMPLICIT tag at current level */
1028                 &asn_DEF_CellGroupId,
1029                 0,
1030                 { 0, 0, 0 },
1031                 0, 0, /* No default value */
1032                 "cellGroup"
1033                 },
1034         { ATF_POINTER, 1, offsetof(struct PDCP_Config__moreThanOneRLC__primaryPath, logicalChannel),
1035                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1036                 -1,     /* IMPLICIT tag at current level */
1037                 &asn_DEF_LogicalChannelIdentity,
1038                 0,
1039                 { 0, 0, 0 },
1040                 0, 0, /* No default value */
1041                 "logicalChannel"
1042                 },
1043 };
1044 static const int asn_MAP_primaryPath_oms_56[] = { 0, 1 };
1045 static const ber_tlv_tag_t asn_DEF_primaryPath_tags_56[] = {
1046         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1047         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1048 };
1049 static const asn_TYPE_tag2member_t asn_MAP_primaryPath_tag2el_56[] = {
1050     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* cellGroup */
1051     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* logicalChannel */
1052 };
1053 static asn_SEQUENCE_specifics_t asn_SPC_primaryPath_specs_56 = {
1054         sizeof(struct PDCP_Config__moreThanOneRLC__primaryPath),
1055         offsetof(struct PDCP_Config__moreThanOneRLC__primaryPath, _asn_ctx),
1056         asn_MAP_primaryPath_tag2el_56,
1057         2,      /* Count of tags in the map */
1058         asn_MAP_primaryPath_oms_56,     /* Optional members */
1059         2, 0,   /* Root/Additions */
1060         -1,     /* First extension addition */
1061 };
1062 static /* Use -fall-defs-global to expose */
1063 asn_TYPE_descriptor_t asn_DEF_primaryPath_56 = {
1064         "primaryPath",
1065         "primaryPath",
1066         &asn_OP_SEQUENCE,
1067         asn_DEF_primaryPath_tags_56,
1068         sizeof(asn_DEF_primaryPath_tags_56)
1069                 /sizeof(asn_DEF_primaryPath_tags_56[0]) - 1, /* 1 */
1070         asn_DEF_primaryPath_tags_56,    /* Same as above */
1071         sizeof(asn_DEF_primaryPath_tags_56)
1072                 /sizeof(asn_DEF_primaryPath_tags_56[0]), /* 2 */
1073         { 0, 0, SEQUENCE_constraint },
1074         asn_MBR_primaryPath_56,
1075         2,      /* Elements count */
1076         &asn_SPC_primaryPath_specs_56   /* Additional specs */
1077 };
1078
1079 static asn_TYPE_member_t asn_MBR_moreThanOneRLC_55[] = {
1080         { ATF_NOFLAGS, 0, offsetof(struct PDCP_Config__moreThanOneRLC, primaryPath),
1081                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1082                 0,
1083                 &asn_DEF_primaryPath_56,
1084                 0,
1085                 { 0, 0, 0 },
1086                 0, 0, /* No default value */
1087                 "primaryPath"
1088                 },
1089         { ATF_POINTER, 2, offsetof(struct PDCP_Config__moreThanOneRLC, ul_DataSplitThreshold),
1090                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1091                 -1,     /* IMPLICIT tag at current level */
1092                 &asn_DEF_UL_DataSplitThreshold,
1093                 0,
1094                 { 0, 0, 0 },
1095                 0, 0, /* No default value */
1096                 "ul-DataSplitThreshold"
1097                 },
1098         { ATF_POINTER, 1, offsetof(struct PDCP_Config__moreThanOneRLC, pdcp_Duplication),
1099                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
1100                 -1,     /* IMPLICIT tag at current level */
1101                 &asn_DEF_BOOLEAN,
1102                 0,
1103                 { 0, 0, 0 },
1104                 0, 0, /* No default value */
1105                 "pdcp-Duplication"
1106                 },
1107 };
1108 static const int asn_MAP_moreThanOneRLC_oms_55[] = { 1, 2 };
1109 static const ber_tlv_tag_t asn_DEF_moreThanOneRLC_tags_55[] = {
1110         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1111         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1112 };
1113 static const asn_TYPE_tag2member_t asn_MAP_moreThanOneRLC_tag2el_55[] = {
1114     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* primaryPath */
1115     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ul-DataSplitThreshold */
1116     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* pdcp-Duplication */
1117 };
1118 static asn_SEQUENCE_specifics_t asn_SPC_moreThanOneRLC_specs_55 = {
1119         sizeof(struct PDCP_Config__moreThanOneRLC),
1120         offsetof(struct PDCP_Config__moreThanOneRLC, _asn_ctx),
1121         asn_MAP_moreThanOneRLC_tag2el_55,
1122         3,      /* Count of tags in the map */
1123         asn_MAP_moreThanOneRLC_oms_55,  /* Optional members */
1124         2, 0,   /* Root/Additions */
1125         -1,     /* First extension addition */
1126 };
1127 static /* Use -fall-defs-global to expose */
1128 asn_TYPE_descriptor_t asn_DEF_moreThanOneRLC_55 = {
1129         "moreThanOneRLC",
1130         "moreThanOneRLC",
1131         &asn_OP_SEQUENCE,
1132         asn_DEF_moreThanOneRLC_tags_55,
1133         sizeof(asn_DEF_moreThanOneRLC_tags_55)
1134                 /sizeof(asn_DEF_moreThanOneRLC_tags_55[0]) - 1, /* 1 */
1135         asn_DEF_moreThanOneRLC_tags_55, /* Same as above */
1136         sizeof(asn_DEF_moreThanOneRLC_tags_55)
1137                 /sizeof(asn_DEF_moreThanOneRLC_tags_55[0]), /* 2 */
1138         { 0, 0, SEQUENCE_constraint },
1139         asn_MBR_moreThanOneRLC_55,
1140         3,      /* Elements count */
1141         &asn_SPC_moreThanOneRLC_specs_55        /* Additional specs */
1142 };
1143
1144 static const asn_INTEGER_enum_map_t asn_MAP_t_Reordering_value2enum_61[] = {
1145         { 0,    3,      "ms0" },
1146         { 1,    3,      "ms1" },
1147         { 2,    3,      "ms2" },
1148         { 3,    3,      "ms4" },
1149         { 4,    3,      "ms5" },
1150         { 5,    3,      "ms8" },
1151         { 6,    4,      "ms10" },
1152         { 7,    4,      "ms15" },
1153         { 8,    4,      "ms20" },
1154         { 9,    4,      "ms30" },
1155         { 10,   4,      "ms40" },
1156         { 11,   4,      "ms50" },
1157         { 12,   4,      "ms60" },
1158         { 13,   4,      "ms80" },
1159         { 14,   5,      "ms100" },
1160         { 15,   5,      "ms120" },
1161         { 16,   5,      "ms140" },
1162         { 17,   5,      "ms160" },
1163         { 18,   5,      "ms180" },
1164         { 19,   5,      "ms200" },
1165         { 20,   5,      "ms220" },
1166         { 21,   5,      "ms240" },
1167         { 22,   5,      "ms260" },
1168         { 23,   5,      "ms280" },
1169         { 24,   5,      "ms300" },
1170         { 25,   5,      "ms500" },
1171         { 26,   5,      "ms750" },
1172         { 27,   6,      "ms1000" },
1173         { 28,   6,      "ms1250" },
1174         { 29,   6,      "ms1500" },
1175         { 30,   6,      "ms1750" },
1176         { 31,   6,      "ms2000" },
1177         { 32,   6,      "ms2250" },
1178         { 33,   6,      "ms2500" },
1179         { 34,   6,      "ms2750" },
1180         { 35,   6,      "ms3000" },
1181         { 36,   7,      "spare28" },
1182         { 37,   7,      "spare27" },
1183         { 38,   7,      "spare26" },
1184         { 39,   7,      "spare25" },
1185         { 40,   7,      "spare24" },
1186         { 41,   7,      "spare23" },
1187         { 42,   7,      "spare22" },
1188         { 43,   7,      "spare21" },
1189         { 44,   7,      "spare20" },
1190         { 45,   7,      "spare19" },
1191         { 46,   7,      "spare18" },
1192         { 47,   7,      "spare17" },
1193         { 48,   7,      "spare16" },
1194         { 49,   7,      "spare15" },
1195         { 50,   7,      "spare14" },
1196         { 51,   7,      "spare13" },
1197         { 52,   7,      "spare12" },
1198         { 53,   7,      "spare11" },
1199         { 54,   7,      "spare10" },
1200         { 55,   7,      "spare09" },
1201         { 56,   7,      "spare08" },
1202         { 57,   7,      "spare07" },
1203         { 58,   7,      "spare06" },
1204         { 59,   7,      "spare05" },
1205         { 60,   7,      "spare04" },
1206         { 61,   7,      "spare03" },
1207         { 62,   7,      "spare02" },
1208         { 63,   7,      "spare01" }
1209 };
1210 static const unsigned int asn_MAP_t_Reordering_enum2value_61[] = {
1211         0,      /* ms0(0) */
1212         1,      /* ms1(1) */
1213         6,      /* ms10(6) */
1214         14,     /* ms100(14) */
1215         27,     /* ms1000(27) */
1216         15,     /* ms120(15) */
1217         28,     /* ms1250(28) */
1218         16,     /* ms140(16) */
1219         7,      /* ms15(7) */
1220         29,     /* ms1500(29) */
1221         17,     /* ms160(17) */
1222         30,     /* ms1750(30) */
1223         18,     /* ms180(18) */
1224         2,      /* ms2(2) */
1225         8,      /* ms20(8) */
1226         19,     /* ms200(19) */
1227         31,     /* ms2000(31) */
1228         20,     /* ms220(20) */
1229         32,     /* ms2250(32) */
1230         21,     /* ms240(21) */
1231         33,     /* ms2500(33) */
1232         22,     /* ms260(22) */
1233         34,     /* ms2750(34) */
1234         23,     /* ms280(23) */
1235         9,      /* ms30(9) */
1236         24,     /* ms300(24) */
1237         35,     /* ms3000(35) */
1238         3,      /* ms4(3) */
1239         10,     /* ms40(10) */
1240         4,      /* ms5(4) */
1241         11,     /* ms50(11) */
1242         25,     /* ms500(25) */
1243         12,     /* ms60(12) */
1244         26,     /* ms750(26) */
1245         5,      /* ms8(5) */
1246         13,     /* ms80(13) */
1247         63,     /* spare01(63) */
1248         62,     /* spare02(62) */
1249         61,     /* spare03(61) */
1250         60,     /* spare04(60) */
1251         59,     /* spare05(59) */
1252         58,     /* spare06(58) */
1253         57,     /* spare07(57) */
1254         56,     /* spare08(56) */
1255         55,     /* spare09(55) */
1256         54,     /* spare10(54) */
1257         53,     /* spare11(53) */
1258         52,     /* spare12(52) */
1259         51,     /* spare13(51) */
1260         50,     /* spare14(50) */
1261         49,     /* spare15(49) */
1262         48,     /* spare16(48) */
1263         47,     /* spare17(47) */
1264         46,     /* spare18(46) */
1265         45,     /* spare19(45) */
1266         44,     /* spare20(44) */
1267         43,     /* spare21(43) */
1268         42,     /* spare22(42) */
1269         41,     /* spare23(41) */
1270         40,     /* spare24(40) */
1271         39,     /* spare25(39) */
1272         38,     /* spare26(38) */
1273         37,     /* spare27(37) */
1274         36      /* spare28(36) */
1275 };
1276 static const asn_INTEGER_specifics_t asn_SPC_t_Reordering_specs_61 = {
1277         asn_MAP_t_Reordering_value2enum_61,     /* "tag" => N; sorted by tag */
1278         asn_MAP_t_Reordering_enum2value_61,     /* N => "tag"; sorted by N */
1279         64,     /* Number of elements in the maps */
1280         0,      /* Enumeration is not extensible */
1281         1,      /* Strict enumeration */
1282         0,      /* Native long size */
1283         0
1284 };
1285 static const ber_tlv_tag_t asn_DEF_t_Reordering_tags_61[] = {
1286         (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
1287         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
1288 };
1289 static /* Use -fall-defs-global to expose */
1290 asn_TYPE_descriptor_t asn_DEF_t_Reordering_61 = {
1291         "t-Reordering",
1292         "t-Reordering",
1293         &asn_OP_NativeEnumerated,
1294         asn_DEF_t_Reordering_tags_61,
1295         sizeof(asn_DEF_t_Reordering_tags_61)
1296                 /sizeof(asn_DEF_t_Reordering_tags_61[0]) - 1, /* 1 */
1297         asn_DEF_t_Reordering_tags_61,   /* Same as above */
1298         sizeof(asn_DEF_t_Reordering_tags_61)
1299                 /sizeof(asn_DEF_t_Reordering_tags_61[0]), /* 2 */
1300         { &asn_OER_type_t_Reordering_constr_61, &asn_PER_type_t_Reordering_constr_61, NativeEnumerated_constraint },
1301         0, 0,   /* Defined elsewhere */
1302         &asn_SPC_t_Reordering_specs_61  /* Additional specs */
1303 };
1304
1305 static const asn_INTEGER_enum_map_t asn_MAP_cipheringDisabled_value2enum_128[] = {
1306         { 0,    4,      "true" }
1307 };
1308 static const unsigned int asn_MAP_cipheringDisabled_enum2value_128[] = {
1309         0       /* true(0) */
1310 };
1311 static const asn_INTEGER_specifics_t asn_SPC_cipheringDisabled_specs_128 = {
1312         asn_MAP_cipheringDisabled_value2enum_128,       /* "tag" => N; sorted by tag */
1313         asn_MAP_cipheringDisabled_enum2value_128,       /* N => "tag"; sorted by N */
1314         1,      /* Number of elements in the maps */
1315         0,      /* Enumeration is not extensible */
1316         1,      /* Strict enumeration */
1317         0,      /* Native long size */
1318         0
1319 };
1320 static const ber_tlv_tag_t asn_DEF_cipheringDisabled_tags_128[] = {
1321         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1322         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
1323 };
1324 static /* Use -fall-defs-global to expose */
1325 asn_TYPE_descriptor_t asn_DEF_cipheringDisabled_128 = {
1326         "cipheringDisabled",
1327         "cipheringDisabled",
1328         &asn_OP_NativeEnumerated,
1329         asn_DEF_cipheringDisabled_tags_128,
1330         sizeof(asn_DEF_cipheringDisabled_tags_128)
1331                 /sizeof(asn_DEF_cipheringDisabled_tags_128[0]) - 1, /* 1 */
1332         asn_DEF_cipheringDisabled_tags_128,     /* Same as above */
1333         sizeof(asn_DEF_cipheringDisabled_tags_128)
1334                 /sizeof(asn_DEF_cipheringDisabled_tags_128[0]), /* 2 */
1335         { &asn_OER_type_cipheringDisabled_constr_128, &asn_PER_type_cipheringDisabled_constr_128, NativeEnumerated_constraint },
1336         0, 0,   /* Defined elsewhere */
1337         &asn_SPC_cipheringDisabled_specs_128    /* Additional specs */
1338 };
1339
1340 static asn_TYPE_member_t asn_MBR_ext1_127[] = {
1341         { ATF_POINTER, 1, offsetof(struct PDCP_Config__ext1, cipheringDisabled),
1342                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1343                 -1,     /* IMPLICIT tag at current level */
1344                 &asn_DEF_cipheringDisabled_128,
1345                 0,
1346                 { 0, 0, 0 },
1347                 0, 0, /* No default value */
1348                 "cipheringDisabled"
1349                 },
1350 };
1351 static const int asn_MAP_ext1_oms_127[] = { 0 };
1352 static const ber_tlv_tag_t asn_DEF_ext1_tags_127[] = {
1353         (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
1354         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1355 };
1356 static const asn_TYPE_tag2member_t asn_MAP_ext1_tag2el_127[] = {
1357     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* cipheringDisabled */
1358 };
1359 static asn_SEQUENCE_specifics_t asn_SPC_ext1_specs_127 = {
1360         sizeof(struct PDCP_Config__ext1),
1361         offsetof(struct PDCP_Config__ext1, _asn_ctx),
1362         asn_MAP_ext1_tag2el_127,
1363         1,      /* Count of tags in the map */
1364         asn_MAP_ext1_oms_127,   /* Optional members */
1365         1, 0,   /* Root/Additions */
1366         -1,     /* First extension addition */
1367 };
1368 static /* Use -fall-defs-global to expose */
1369 asn_TYPE_descriptor_t asn_DEF_ext1_127 = {
1370         "ext1",
1371         "ext1",
1372         &asn_OP_SEQUENCE,
1373         asn_DEF_ext1_tags_127,
1374         sizeof(asn_DEF_ext1_tags_127)
1375                 /sizeof(asn_DEF_ext1_tags_127[0]) - 1, /* 1 */
1376         asn_DEF_ext1_tags_127,  /* Same as above */
1377         sizeof(asn_DEF_ext1_tags_127)
1378                 /sizeof(asn_DEF_ext1_tags_127[0]), /* 2 */
1379         { 0, 0, SEQUENCE_constraint },
1380         asn_MBR_ext1_127,
1381         1,      /* Elements count */
1382         &asn_SPC_ext1_specs_127 /* Additional specs */
1383 };
1384
1385 asn_TYPE_member_t asn_MBR_PDCP_Config_1[] = {
1386         { ATF_POINTER, 4, offsetof(struct PDCP_Config, drb),
1387                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1388                 0,
1389                 &asn_DEF_drb_2,
1390                 0,
1391                 { 0, 0, 0 },
1392                 0, 0, /* No default value */
1393                 "drb"
1394                 },
1395         { ATF_POINTER, 3, offsetof(struct PDCP_Config, moreThanOneRLC),
1396                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1397                 0,
1398                 &asn_DEF_moreThanOneRLC_55,
1399                 0,
1400                 { 0, 0, 0 },
1401                 0, 0, /* No default value */
1402                 "moreThanOneRLC"
1403                 },
1404         { ATF_POINTER, 2, offsetof(struct PDCP_Config, t_Reordering),
1405                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
1406                 -1,     /* IMPLICIT tag at current level */
1407                 &asn_DEF_t_Reordering_61,
1408                 0,
1409                 { 0, 0, 0 },
1410                 0, 0, /* No default value */
1411                 "t-Reordering"
1412                 },
1413         { ATF_POINTER, 1, offsetof(struct PDCP_Config, ext1),
1414                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
1415                 0,
1416                 &asn_DEF_ext1_127,
1417                 0,
1418                 { 0, 0, 0 },
1419                 0, 0, /* No default value */
1420                 "ext1"
1421                 },
1422 };
1423 static const int asn_MAP_PDCP_Config_oms_1[] = { 0, 1, 2, 3 };
1424 static const ber_tlv_tag_t asn_DEF_PDCP_Config_tags_1[] = {
1425         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1426 };
1427 static const asn_TYPE_tag2member_t asn_MAP_PDCP_Config_tag2el_1[] = {
1428     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* drb */
1429     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* moreThanOneRLC */
1430     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* t-Reordering */
1431     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* ext1 */
1432 };
1433 asn_SEQUENCE_specifics_t asn_SPC_PDCP_Config_specs_1 = {
1434         sizeof(struct PDCP_Config),
1435         offsetof(struct PDCP_Config, _asn_ctx),
1436         asn_MAP_PDCP_Config_tag2el_1,
1437         4,      /* Count of tags in the map */
1438         asn_MAP_PDCP_Config_oms_1,      /* Optional members */
1439         3, 1,   /* Root/Additions */
1440         3,      /* First extension addition */
1441 };
1442 asn_TYPE_descriptor_t asn_DEF_PDCP_Config = {
1443         "PDCP-Config",
1444         "PDCP-Config",
1445         &asn_OP_SEQUENCE,
1446         asn_DEF_PDCP_Config_tags_1,
1447         sizeof(asn_DEF_PDCP_Config_tags_1)
1448                 /sizeof(asn_DEF_PDCP_Config_tags_1[0]), /* 1 */
1449         asn_DEF_PDCP_Config_tags_1,     /* Same as above */
1450         sizeof(asn_DEF_PDCP_Config_tags_1)
1451                 /sizeof(asn_DEF_PDCP_Config_tags_1[0]), /* 1 */
1452         { 0, 0, SEQUENCE_constraint },
1453         asn_MBR_PDCP_Config_1,
1454         4,      /* Elements count */
1455         &asn_SPC_PDCP_Config_specs_1    /* Additional specs */
1456 };
1457