src/codec_utils/RRC/CodebookConfig.c

   1 /*
   2  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
   3  * From ASN.1 module "NR-RRC-Definitions"
   4  *      found in "./22April22_Paging/rrc_15.3_asn.asn1"
   5  *      `asn1c -D ./22April22_Paging -fcompound-names -fno-include-deps -findirect-choice -gen-PER -no-gen-example`
   6  */
   7
   8 #include "CodebookConfig.h"
   9
  10 static int
  11 memb_twoTX_CodebookSubsetRestriction_constraint_7(const asn_TYPE_descriptor_t *td, const void *sptr,
  12                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  13         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
  14         size_t size;
  15
  16         if(!sptr) {
  17                 ASN__CTFAIL(app_key, td, sptr,
  18                         "%s: value not given (%s:%d)",
  19                         td->name, __FILE__, __LINE__);
  20                 return -1;
  21         }
  22
  23         if(st->size > 0) {
  24                 /* Size in bits */
  25                 size = 8 * st->size - (st->bits_unused & 0x07);
  26         } else {
  27                 size = 0;
  28         }
  29
  30         if((size == 6)) {
  31                 /* Constraint check succeeded */
  32                 return 0;
  33         } else {
  34                 ASN__CTFAIL(app_key, td, sptr,
  35                         "%s: constraint failed (%s:%d)",
  36                         td->name, __FILE__, __LINE__);
  37                 return -1;
  38         }
  39 }
  40
  41 static int
  42 memb_two_one_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
  43                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  44         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
  45         size_t size;
  46
  47         if(!sptr) {
  48                 ASN__CTFAIL(app_key, td, sptr,
  49                         "%s: value not given (%s:%d)",
  50                         td->name, __FILE__, __LINE__);
  51                 return -1;
  52         }
  53
  54         if(st->size > 0) {
  55                 /* Size in bits */
  56                 size = 8 * st->size - (st->bits_unused & 0x07);
  57         } else {
  58                 size = 0;
  59         }
  60
  61         if((size == 8)) {
  62                 /* Constraint check succeeded */
  63                 return 0;
  64         } else {
  65                 ASN__CTFAIL(app_key, td, sptr,
  66                         "%s: constraint failed (%s:%d)",
  67                         td->name, __FILE__, __LINE__);
  68                 return -1;
  69         }
  70 }
  71
  72 static int
  73 memb_two_two_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
  74                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  75         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
  76         size_t size;
  77
  78         if(!sptr) {
  79                 ASN__CTFAIL(app_key, td, sptr,
  80                         "%s: value not given (%s:%d)",
  81                         td->name, __FILE__, __LINE__);
  82                 return -1;
  83         }
  84
  85         if(st->size > 0) {
  86                 /* Size in bits */
  87                 size = 8 * st->size - (st->bits_unused & 0x07);
  88         } else {
  89                 size = 0;
  90         }
  91
  92         if((size == 64)) {
  93                 /* Constraint check succeeded */
  94                 return 0;
  95         } else {
  96                 ASN__CTFAIL(app_key, td, sptr,
  97                         "%s: constraint failed (%s:%d)",
  98                         td->name, __FILE__, __LINE__);
  99                 return -1;
 100         }
 101 }
 102
 103 static int
 104 memb_four_one_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 105                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 106         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 107         size_t size;
 108
 109         if(!sptr) {
 110                 ASN__CTFAIL(app_key, td, sptr,
 111                         "%s: value not given (%s:%d)",
 112                         td->name, __FILE__, __LINE__);
 113                 return -1;
 114         }
 115
 116         if(st->size > 0) {
 117                 /* Size in bits */
 118                 size = 8 * st->size - (st->bits_unused & 0x07);
 119         } else {
 120                 size = 0;
 121         }
 122
 123         if((size == 16)) {
 124                 /* Constraint check succeeded */
 125                 return 0;
 126         } else {
 127                 ASN__CTFAIL(app_key, td, sptr,
 128                         "%s: constraint failed (%s:%d)",
 129                         td->name, __FILE__, __LINE__);
 130                 return -1;
 131         }
 132 }
 133
 134 static int
 135 memb_three_two_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 136                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 137         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 138         size_t size;
 139
 140         if(!sptr) {
 141                 ASN__CTFAIL(app_key, td, sptr,
 142                         "%s: value not given (%s:%d)",
 143                         td->name, __FILE__, __LINE__);
 144                 return -1;
 145         }
 146
 147         if(st->size > 0) {
 148                 /* Size in bits */
 149                 size = 8 * st->size - (st->bits_unused & 0x07);
 150         } else {
 151                 size = 0;
 152         }
 153
 154         if((size == 96)) {
 155                 /* Constraint check succeeded */
 156                 return 0;
 157         } else {
 158                 ASN__CTFAIL(app_key, td, sptr,
 159                         "%s: constraint failed (%s:%d)",
 160                         td->name, __FILE__, __LINE__);
 161                 return -1;
 162         }
 163 }
 164
 165 static int
 166 memb_six_one_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 167                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 168         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 169         size_t size;
 170
 171         if(!sptr) {
 172                 ASN__CTFAIL(app_key, td, sptr,
 173                         "%s: value not given (%s:%d)",
 174                         td->name, __FILE__, __LINE__);
 175                 return -1;
 176         }
 177
 178         if(st->size > 0) {
 179                 /* Size in bits */
 180                 size = 8 * st->size - (st->bits_unused & 0x07);
 181         } else {
 182                 size = 0;
 183         }
 184
 185         if((size == 24)) {
 186                 /* Constraint check succeeded */
 187                 return 0;
 188         } else {
 189                 ASN__CTFAIL(app_key, td, sptr,
 190                         "%s: constraint failed (%s:%d)",
 191                         td->name, __FILE__, __LINE__);
 192                 return -1;
 193         }
 194 }
 195
 196 static int
 197 memb_four_two_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 198                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 199         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 200         size_t size;
 201
 202         if(!sptr) {
 203                 ASN__CTFAIL(app_key, td, sptr,
 204                         "%s: value not given (%s:%d)",
 205                         td->name, __FILE__, __LINE__);
 206                 return -1;
 207         }
 208
 209         if(st->size > 0) {
 210                 /* Size in bits */
 211                 size = 8 * st->size - (st->bits_unused & 0x07);
 212         } else {
 213                 size = 0;
 214         }
 215
 216         if((size == 128)) {
 217                 /* Constraint check succeeded */
 218                 return 0;
 219         } else {
 220                 ASN__CTFAIL(app_key, td, sptr,
 221                         "%s: constraint failed (%s:%d)",
 222                         td->name, __FILE__, __LINE__);
 223                 return -1;
 224         }
 225 }
 226
 227 static int
 228 memb_eight_one_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 229                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 230         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 231         size_t size;
 232
 233         if(!sptr) {
 234                 ASN__CTFAIL(app_key, td, sptr,
 235                         "%s: value not given (%s:%d)",
 236                         td->name, __FILE__, __LINE__);
 237                 return -1;
 238         }
 239
 240         if(st->size > 0) {
 241                 /* Size in bits */
 242                 size = 8 * st->size - (st->bits_unused & 0x07);
 243         } else {
 244                 size = 0;
 245         }
 246
 247         if((size == 32)) {
 248                 /* Constraint check succeeded */
 249                 return 0;
 250         } else {
 251                 ASN__CTFAIL(app_key, td, sptr,
 252                         "%s: constraint failed (%s:%d)",
 253                         td->name, __FILE__, __LINE__);
 254                 return -1;
 255         }
 256 }
 257
 258 static int
 259 memb_four_three_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 260                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 261         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 262         size_t size;
 263
 264         if(!sptr) {
 265                 ASN__CTFAIL(app_key, td, sptr,
 266                         "%s: value not given (%s:%d)",
 267                         td->name, __FILE__, __LINE__);
 268                 return -1;
 269         }
 270
 271         if(st->size > 0) {
 272                 /* Size in bits */
 273                 size = 8 * st->size - (st->bits_unused & 0x07);
 274         } else {
 275                 size = 0;
 276         }
 277
 278         if((size == 192)) {
 279                 /* Constraint check succeeded */
 280                 return 0;
 281         } else {
 282                 ASN__CTFAIL(app_key, td, sptr,
 283                         "%s: constraint failed (%s:%d)",
 284                         td->name, __FILE__, __LINE__);
 285                 return -1;
 286         }
 287 }
 288
 289 static int
 290 memb_six_two_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 291                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 292         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 293         size_t size;
 294
 295         if(!sptr) {
 296                 ASN__CTFAIL(app_key, td, sptr,
 297                         "%s: value not given (%s:%d)",
 298                         td->name, __FILE__, __LINE__);
 299                 return -1;
 300         }
 301
 302         if(st->size > 0) {
 303                 /* Size in bits */
 304                 size = 8 * st->size - (st->bits_unused & 0x07);
 305         } else {
 306                 size = 0;
 307         }
 308
 309         if((size == 192)) {
 310                 /* Constraint check succeeded */
 311                 return 0;
 312         } else {
 313                 ASN__CTFAIL(app_key, td, sptr,
 314                         "%s: constraint failed (%s:%d)",
 315                         td->name, __FILE__, __LINE__);
 316                 return -1;
 317         }
 318 }
 319
 320 static int
 321 memb_twelve_one_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 322                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 323         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 324         size_t size;
 325
 326         if(!sptr) {
 327                 ASN__CTFAIL(app_key, td, sptr,
 328                         "%s: value not given (%s:%d)",
 329                         td->name, __FILE__, __LINE__);
 330                 return -1;
 331         }
 332
 333         if(st->size > 0) {
 334                 /* Size in bits */
 335                 size = 8 * st->size - (st->bits_unused & 0x07);
 336         } else {
 337                 size = 0;
 338         }
 339
 340         if((size == 48)) {
 341                 /* Constraint check succeeded */
 342                 return 0;
 343         } else {
 344                 ASN__CTFAIL(app_key, td, sptr,
 345                         "%s: constraint failed (%s:%d)",
 346                         td->name, __FILE__, __LINE__);
 347                 return -1;
 348         }
 349 }
 350
 351 static int
 352 memb_four_four_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 353                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 354         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 355         size_t size;
 356
 357         if(!sptr) {
 358                 ASN__CTFAIL(app_key, td, sptr,
 359                         "%s: value not given (%s:%d)",
 360                         td->name, __FILE__, __LINE__);
 361                 return -1;
 362         }
 363
 364         if(st->size > 0) {
 365                 /* Size in bits */
 366                 size = 8 * st->size - (st->bits_unused & 0x07);
 367         } else {
 368                 size = 0;
 369         }
 370
 371         if((size == 256)) {
 372                 /* Constraint check succeeded */
 373                 return 0;
 374         } else {
 375                 ASN__CTFAIL(app_key, td, sptr,
 376                         "%s: constraint failed (%s:%d)",
 377                         td->name, __FILE__, __LINE__);
 378                 return -1;
 379         }
 380 }
 381
 382 static int
 383 memb_eight_two_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 384                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 385         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 386         size_t size;
 387
 388         if(!sptr) {
 389                 ASN__CTFAIL(app_key, td, sptr,
 390                         "%s: value not given (%s:%d)",
 391                         td->name, __FILE__, __LINE__);
 392                 return -1;
 393         }
 394
 395         if(st->size > 0) {
 396                 /* Size in bits */
 397                 size = 8 * st->size - (st->bits_unused & 0x07);
 398         } else {
 399                 size = 0;
 400         }
 401
 402         if((size == 256)) {
 403                 /* Constraint check succeeded */
 404                 return 0;
 405         } else {
 406                 ASN__CTFAIL(app_key, td, sptr,
 407                         "%s: constraint failed (%s:%d)",
 408                         td->name, __FILE__, __LINE__);
 409                 return -1;
 410         }
 411 }
 412
 413 static int
 414 memb_sixteen_one_TypeI_SinglePanel_Restriction_constraint_10(const asn_TYPE_descriptor_t *td, const void *sptr,
 415                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 416         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 417         size_t size;
 418
 419         if(!sptr) {
 420                 ASN__CTFAIL(app_key, td, sptr,
 421                         "%s: value not given (%s:%d)",
 422                         td->name, __FILE__, __LINE__);
 423                 return -1;
 424         }
 425
 426         if(st->size > 0) {
 427                 /* Size in bits */
 428                 size = 8 * st->size - (st->bits_unused & 0x07);
 429         } else {
 430                 size = 0;
 431         }
 432
 433         if((size == 64)) {
 434                 /* Constraint check succeeded */
 435                 return 0;
 436         } else {
 437                 ASN__CTFAIL(app_key, td, sptr,
 438                         "%s: constraint failed (%s:%d)",
 439                         td->name, __FILE__, __LINE__);
 440                 return -1;
 441         }
 442 }
 443
 444 static int
 445 memb_typeI_SinglePanel_codebookSubsetRestriction_i2_constraint_9(const asn_TYPE_descriptor_t *td, const void *sptr,
 446                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 447         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 448         size_t size;
 449
 450         if(!sptr) {
 451                 ASN__CTFAIL(app_key, td, sptr,
 452                         "%s: value not given (%s:%d)",
 453                         td->name, __FILE__, __LINE__);
 454                 return -1;
 455         }
 456
 457         if(st->size > 0) {
 458                 /* Size in bits */
 459                 size = 8 * st->size - (st->bits_unused & 0x07);
 460         } else {
 461                 size = 0;
 462         }
 463
 464         if((size == 16)) {
 465                 /* Constraint check succeeded */
 466                 return 0;
 467         } else {
 468                 ASN__CTFAIL(app_key, td, sptr,
 469                         "%s: constraint failed (%s:%d)",
 470                         td->name, __FILE__, __LINE__);
 471                 return -1;
 472         }
 473 }
 474
 475 static int
 476 memb_typeI_SinglePanel_ri_Restriction_constraint_5(const asn_TYPE_descriptor_t *td, const void *sptr,
 477                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 478         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 479         size_t size;
 480
 481         if(!sptr) {
 482                 ASN__CTFAIL(app_key, td, sptr,
 483                         "%s: value not given (%s:%d)",
 484                         td->name, __FILE__, __LINE__);
 485                 return -1;
 486         }
 487
 488         if(st->size > 0) {
 489                 /* Size in bits */
 490                 size = 8 * st->size - (st->bits_unused & 0x07);
 491         } else {
 492                 size = 0;
 493         }
 494
 495         if((size == 8)) {
 496                 /* Constraint check succeeded */
 497                 return 0;
 498         } else {
 499                 ASN__CTFAIL(app_key, td, sptr,
 500                         "%s: constraint failed (%s:%d)",
 501                         td->name, __FILE__, __LINE__);
 502                 return -1;
 503         }
 504 }
 505
 506 static int
 507 memb_two_two_one_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 508                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 509         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 510         size_t size;
 511
 512         if(!sptr) {
 513                 ASN__CTFAIL(app_key, td, sptr,
 514                         "%s: value not given (%s:%d)",
 515                         td->name, __FILE__, __LINE__);
 516                 return -1;
 517         }
 518
 519         if(st->size > 0) {
 520                 /* Size in bits */
 521                 size = 8 * st->size - (st->bits_unused & 0x07);
 522         } else {
 523                 size = 0;
 524         }
 525
 526         if((size == 8)) {
 527                 /* Constraint check succeeded */
 528                 return 0;
 529         } else {
 530                 ASN__CTFAIL(app_key, td, sptr,
 531                         "%s: constraint failed (%s:%d)",
 532                         td->name, __FILE__, __LINE__);
 533                 return -1;
 534         }
 535 }
 536
 537 static int
 538 memb_two_four_one_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 539                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 540         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 541         size_t size;
 542
 543         if(!sptr) {
 544                 ASN__CTFAIL(app_key, td, sptr,
 545                         "%s: value not given (%s:%d)",
 546                         td->name, __FILE__, __LINE__);
 547                 return -1;
 548         }
 549
 550         if(st->size > 0) {
 551                 /* Size in bits */
 552                 size = 8 * st->size - (st->bits_unused & 0x07);
 553         } else {
 554                 size = 0;
 555         }
 556
 557         if((size == 16)) {
 558                 /* Constraint check succeeded */
 559                 return 0;
 560         } else {
 561                 ASN__CTFAIL(app_key, td, sptr,
 562                         "%s: constraint failed (%s:%d)",
 563                         td->name, __FILE__, __LINE__);
 564                 return -1;
 565         }
 566 }
 567
 568 static int
 569 memb_four_two_one_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 570                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 571         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 572         size_t size;
 573
 574         if(!sptr) {
 575                 ASN__CTFAIL(app_key, td, sptr,
 576                         "%s: value not given (%s:%d)",
 577                         td->name, __FILE__, __LINE__);
 578                 return -1;
 579         }
 580
 581         if(st->size > 0) {
 582                 /* Size in bits */
 583                 size = 8 * st->size - (st->bits_unused & 0x07);
 584         } else {
 585                 size = 0;
 586         }
 587
 588         if((size == 8)) {
 589                 /* Constraint check succeeded */
 590                 return 0;
 591         } else {
 592                 ASN__CTFAIL(app_key, td, sptr,
 593                         "%s: constraint failed (%s:%d)",
 594                         td->name, __FILE__, __LINE__);
 595                 return -1;
 596         }
 597 }
 598
 599 static int
 600 memb_two_two_two_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 601                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 602         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 603         size_t size;
 604
 605         if(!sptr) {
 606                 ASN__CTFAIL(app_key, td, sptr,
 607                         "%s: value not given (%s:%d)",
 608                         td->name, __FILE__, __LINE__);
 609                 return -1;
 610         }
 611
 612         if(st->size > 0) {
 613                 /* Size in bits */
 614                 size = 8 * st->size - (st->bits_unused & 0x07);
 615         } else {
 616                 size = 0;
 617         }
 618
 619         if((size == 64)) {
 620                 /* Constraint check succeeded */
 621                 return 0;
 622         } else {
 623                 ASN__CTFAIL(app_key, td, sptr,
 624                         "%s: constraint failed (%s:%d)",
 625                         td->name, __FILE__, __LINE__);
 626                 return -1;
 627         }
 628 }
 629
 630 static int
 631 memb_two_eight_one_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 632                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 633         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 634         size_t size;
 635
 636         if(!sptr) {
 637                 ASN__CTFAIL(app_key, td, sptr,
 638                         "%s: value not given (%s:%d)",
 639                         td->name, __FILE__, __LINE__);
 640                 return -1;
 641         }
 642
 643         if(st->size > 0) {
 644                 /* Size in bits */
 645                 size = 8 * st->size - (st->bits_unused & 0x07);
 646         } else {
 647                 size = 0;
 648         }
 649
 650         if((size == 32)) {
 651                 /* Constraint check succeeded */
 652                 return 0;
 653         } else {
 654                 ASN__CTFAIL(app_key, td, sptr,
 655                         "%s: constraint failed (%s:%d)",
 656                         td->name, __FILE__, __LINE__);
 657                 return -1;
 658         }
 659 }
 660
 661 static int
 662 memb_four_four_one_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 663                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 664         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 665         size_t size;
 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         if(st->size > 0) {
 675                 /* Size in bits */
 676                 size = 8 * st->size - (st->bits_unused & 0x07);
 677         } else {
 678                 size = 0;
 679         }
 680
 681         if((size == 16)) {
 682                 /* Constraint check succeeded */
 683                 return 0;
 684         } else {
 685                 ASN__CTFAIL(app_key, td, sptr,
 686                         "%s: constraint failed (%s:%d)",
 687                         td->name, __FILE__, __LINE__);
 688                 return -1;
 689         }
 690 }
 691
 692 static int
 693 memb_two_four_two_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 694                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 695         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 696         size_t size;
 697
 698         if(!sptr) {
 699                 ASN__CTFAIL(app_key, td, sptr,
 700                         "%s: value not given (%s:%d)",
 701                         td->name, __FILE__, __LINE__);
 702                 return -1;
 703         }
 704
 705         if(st->size > 0) {
 706                 /* Size in bits */
 707                 size = 8 * st->size - (st->bits_unused & 0x07);
 708         } else {
 709                 size = 0;
 710         }
 711
 712         if((size == 128)) {
 713                 /* Constraint check succeeded */
 714                 return 0;
 715         } else {
 716                 ASN__CTFAIL(app_key, td, sptr,
 717                         "%s: constraint failed (%s:%d)",
 718                         td->name, __FILE__, __LINE__);
 719                 return -1;
 720         }
 721 }
 722
 723 static int
 724 memb_four_two_two_TypeI_MultiPanel_Restriction_constraint_27(const asn_TYPE_descriptor_t *td, const void *sptr,
 725                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 726         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 727         size_t size;
 728
 729         if(!sptr) {
 730                 ASN__CTFAIL(app_key, td, sptr,
 731                         "%s: value not given (%s:%d)",
 732                         td->name, __FILE__, __LINE__);
 733                 return -1;
 734         }
 735
 736         if(st->size > 0) {
 737                 /* Size in bits */
 738                 size = 8 * st->size - (st->bits_unused & 0x07);
 739         } else {
 740                 size = 0;
 741         }
 742
 743         if((size == 64)) {
 744                 /* Constraint check succeeded */
 745                 return 0;
 746         } else {
 747                 ASN__CTFAIL(app_key, td, sptr,
 748                         "%s: constraint failed (%s:%d)",
 749                         td->name, __FILE__, __LINE__);
 750                 return -1;
 751         }
 752 }
 753
 754 static int
 755 memb_ri_Restriction_constraint_26(const asn_TYPE_descriptor_t *td, const void *sptr,
 756                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 757         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 758         size_t size;
 759
 760         if(!sptr) {
 761                 ASN__CTFAIL(app_key, td, sptr,
 762                         "%s: value not given (%s:%d)",
 763                         td->name, __FILE__, __LINE__);
 764                 return -1;
 765         }
 766
 767         if(st->size > 0) {
 768                 /* Size in bits */
 769                 size = 8 * st->size - (st->bits_unused & 0x07);
 770         } else {
 771                 size = 0;
 772         }
 773
 774         if((size == 4)) {
 775                 /* Constraint check succeeded */
 776                 return 0;
 777         } else {
 778                 ASN__CTFAIL(app_key, td, sptr,
 779                         "%s: constraint failed (%s:%d)",
 780                         td->name, __FILE__, __LINE__);
 781                 return -1;
 782         }
 783 }
 784
 785 static int
 786 memb_codebookMode_constraint_3(const asn_TYPE_descriptor_t *td, const void *sptr,
 787                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 788         long value;
 789
 790         if(!sptr) {
 791                 ASN__CTFAIL(app_key, td, sptr,
 792                         "%s: value not given (%s:%d)",
 793                         td->name, __FILE__, __LINE__);
 794                 return -1;
 795         }
 796
 797         value = *(const long *)sptr;
 798
 799         if((value >= 1 && value <= 2)) {
 800                 /* Constraint check succeeded */
 801                 return 0;
 802         } else {
 803                 ASN__CTFAIL(app_key, td, sptr,
 804                         "%s: constraint failed (%s:%d)",
 805                         td->name, __FILE__, __LINE__);
 806                 return -1;
 807         }
 808 }
 809
 810 static int
 811 memb_two_one_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 812                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 813         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 814         size_t size;
 815
 816         if(!sptr) {
 817                 ASN__CTFAIL(app_key, td, sptr,
 818                         "%s: value not given (%s:%d)",
 819                         td->name, __FILE__, __LINE__);
 820                 return -1;
 821         }
 822
 823         if(st->size > 0) {
 824                 /* Size in bits */
 825                 size = 8 * st->size - (st->bits_unused & 0x07);
 826         } else {
 827                 size = 0;
 828         }
 829
 830         if((size == 16)) {
 831                 /* Constraint check succeeded */
 832                 return 0;
 833         } else {
 834                 ASN__CTFAIL(app_key, td, sptr,
 835                         "%s: constraint failed (%s:%d)",
 836                         td->name, __FILE__, __LINE__);
 837                 return -1;
 838         }
 839 }
 840
 841 static int
 842 memb_two_two_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 843                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 844         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 845         size_t size;
 846
 847         if(!sptr) {
 848                 ASN__CTFAIL(app_key, td, sptr,
 849                         "%s: value not given (%s:%d)",
 850                         td->name, __FILE__, __LINE__);
 851                 return -1;
 852         }
 853
 854         if(st->size > 0) {
 855                 /* Size in bits */
 856                 size = 8 * st->size - (st->bits_unused & 0x07);
 857         } else {
 858                 size = 0;
 859         }
 860
 861         if((size == 43)) {
 862                 /* Constraint check succeeded */
 863                 return 0;
 864         } else {
 865                 ASN__CTFAIL(app_key, td, sptr,
 866                         "%s: constraint failed (%s:%d)",
 867                         td->name, __FILE__, __LINE__);
 868                 return -1;
 869         }
 870 }
 871
 872 static int
 873 memb_four_one_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 874                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 875         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 876         size_t size;
 877
 878         if(!sptr) {
 879                 ASN__CTFAIL(app_key, td, sptr,
 880                         "%s: value not given (%s:%d)",
 881                         td->name, __FILE__, __LINE__);
 882                 return -1;
 883         }
 884
 885         if(st->size > 0) {
 886                 /* Size in bits */
 887                 size = 8 * st->size - (st->bits_unused & 0x07);
 888         } else {
 889                 size = 0;
 890         }
 891
 892         if((size == 32)) {
 893                 /* Constraint check succeeded */
 894                 return 0;
 895         } else {
 896                 ASN__CTFAIL(app_key, td, sptr,
 897                         "%s: constraint failed (%s:%d)",
 898                         td->name, __FILE__, __LINE__);
 899                 return -1;
 900         }
 901 }
 902
 903 static int
 904 memb_three_two_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 905                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 906         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 907         size_t size;
 908
 909         if(!sptr) {
 910                 ASN__CTFAIL(app_key, td, sptr,
 911                         "%s: value not given (%s:%d)",
 912                         td->name, __FILE__, __LINE__);
 913                 return -1;
 914         }
 915
 916         if(st->size > 0) {
 917                 /* Size in bits */
 918                 size = 8 * st->size - (st->bits_unused & 0x07);
 919         } else {
 920                 size = 0;
 921         }
 922
 923         if((size == 59)) {
 924                 /* Constraint check succeeded */
 925                 return 0;
 926         } else {
 927                 ASN__CTFAIL(app_key, td, sptr,
 928                         "%s: constraint failed (%s:%d)",
 929                         td->name, __FILE__, __LINE__);
 930                 return -1;
 931         }
 932 }
 933
 934 static int
 935 memb_six_one_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 936                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 937         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 938         size_t size;
 939
 940         if(!sptr) {
 941                 ASN__CTFAIL(app_key, td, sptr,
 942                         "%s: value not given (%s:%d)",
 943                         td->name, __FILE__, __LINE__);
 944                 return -1;
 945         }
 946
 947         if(st->size > 0) {
 948                 /* Size in bits */
 949                 size = 8 * st->size - (st->bits_unused & 0x07);
 950         } else {
 951                 size = 0;
 952         }
 953
 954         if((size == 48)) {
 955                 /* Constraint check succeeded */
 956                 return 0;
 957         } else {
 958                 ASN__CTFAIL(app_key, td, sptr,
 959                         "%s: constraint failed (%s:%d)",
 960                         td->name, __FILE__, __LINE__);
 961                 return -1;
 962         }
 963 }
 964
 965 static int
 966 memb_four_two_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 967                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 968         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 969         size_t size;
 970
 971         if(!sptr) {
 972                 ASN__CTFAIL(app_key, td, sptr,
 973                         "%s: value not given (%s:%d)",
 974                         td->name, __FILE__, __LINE__);
 975                 return -1;
 976         }
 977
 978         if(st->size > 0) {
 979                 /* Size in bits */
 980                 size = 8 * st->size - (st->bits_unused & 0x07);
 981         } else {
 982                 size = 0;
 983         }
 984
 985         if((size == 75)) {
 986                 /* Constraint check succeeded */
 987                 return 0;
 988         } else {
 989                 ASN__CTFAIL(app_key, td, sptr,
 990                         "%s: constraint failed (%s:%d)",
 991                         td->name, __FILE__, __LINE__);
 992                 return -1;
 993         }
 994 }
 995
 996 static int
 997 memb_eight_one_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
 998                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 999         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1000         size_t size;
1001
1002         if(!sptr) {
1003                 ASN__CTFAIL(app_key, td, sptr,
1004                         "%s: value not given (%s:%d)",
1005                         td->name, __FILE__, __LINE__);
1006                 return -1;
1007         }
1008
1009         if(st->size > 0) {
1010                 /* Size in bits */
1011                 size = 8 * st->size - (st->bits_unused & 0x07);
1012         } else {
1013                 size = 0;
1014         }
1015
1016         if((size == 64)) {
1017                 /* Constraint check succeeded */
1018                 return 0;
1019         } else {
1020                 ASN__CTFAIL(app_key, td, sptr,
1021                         "%s: constraint failed (%s:%d)",
1022                         td->name, __FILE__, __LINE__);
1023                 return -1;
1024         }
1025 }
1026
1027 static int
1028 memb_four_three_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1029                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1030         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1031         size_t size;
1032
1033         if(!sptr) {
1034                 ASN__CTFAIL(app_key, td, sptr,
1035                         "%s: value not given (%s:%d)",
1036                         td->name, __FILE__, __LINE__);
1037                 return -1;
1038         }
1039
1040         if(st->size > 0) {
1041                 /* Size in bits */
1042                 size = 8 * st->size - (st->bits_unused & 0x07);
1043         } else {
1044                 size = 0;
1045         }
1046
1047         if((size == 107)) {
1048                 /* Constraint check succeeded */
1049                 return 0;
1050         } else {
1051                 ASN__CTFAIL(app_key, td, sptr,
1052                         "%s: constraint failed (%s:%d)",
1053                         td->name, __FILE__, __LINE__);
1054                 return -1;
1055         }
1056 }
1057
1058 static int
1059 memb_six_two_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1060                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1061         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1062         size_t size;
1063
1064         if(!sptr) {
1065                 ASN__CTFAIL(app_key, td, sptr,
1066                         "%s: value not given (%s:%d)",
1067                         td->name, __FILE__, __LINE__);
1068                 return -1;
1069         }
1070
1071         if(st->size > 0) {
1072                 /* Size in bits */
1073                 size = 8 * st->size - (st->bits_unused & 0x07);
1074         } else {
1075                 size = 0;
1076         }
1077
1078         if((size == 107)) {
1079                 /* Constraint check succeeded */
1080                 return 0;
1081         } else {
1082                 ASN__CTFAIL(app_key, td, sptr,
1083                         "%s: constraint failed (%s:%d)",
1084                         td->name, __FILE__, __LINE__);
1085                 return -1;
1086         }
1087 }
1088
1089 static int
1090 memb_twelve_one_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1091                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1092         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1093         size_t size;
1094
1095         if(!sptr) {
1096                 ASN__CTFAIL(app_key, td, sptr,
1097                         "%s: value not given (%s:%d)",
1098                         td->name, __FILE__, __LINE__);
1099                 return -1;
1100         }
1101
1102         if(st->size > 0) {
1103                 /* Size in bits */
1104                 size = 8 * st->size - (st->bits_unused & 0x07);
1105         } else {
1106                 size = 0;
1107         }
1108
1109         if((size == 96)) {
1110                 /* Constraint check succeeded */
1111                 return 0;
1112         } else {
1113                 ASN__CTFAIL(app_key, td, sptr,
1114                         "%s: constraint failed (%s:%d)",
1115                         td->name, __FILE__, __LINE__);
1116                 return -1;
1117         }
1118 }
1119
1120 static int
1121 memb_four_four_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1122                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1123         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1124         size_t size;
1125
1126         if(!sptr) {
1127                 ASN__CTFAIL(app_key, td, sptr,
1128                         "%s: value not given (%s:%d)",
1129                         td->name, __FILE__, __LINE__);
1130                 return -1;
1131         }
1132
1133         if(st->size > 0) {
1134                 /* Size in bits */
1135                 size = 8 * st->size - (st->bits_unused & 0x07);
1136         } else {
1137                 size = 0;
1138         }
1139
1140         if((size == 139)) {
1141                 /* Constraint check succeeded */
1142                 return 0;
1143         } else {
1144                 ASN__CTFAIL(app_key, td, sptr,
1145                         "%s: constraint failed (%s:%d)",
1146                         td->name, __FILE__, __LINE__);
1147                 return -1;
1148         }
1149 }
1150
1151 static int
1152 memb_eight_two_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1153                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1154         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1155         size_t size;
1156
1157         if(!sptr) {
1158                 ASN__CTFAIL(app_key, td, sptr,
1159                         "%s: value not given (%s:%d)",
1160                         td->name, __FILE__, __LINE__);
1161                 return -1;
1162         }
1163
1164         if(st->size > 0) {
1165                 /* Size in bits */
1166                 size = 8 * st->size - (st->bits_unused & 0x07);
1167         } else {
1168                 size = 0;
1169         }
1170
1171         if((size == 139)) {
1172                 /* Constraint check succeeded */
1173                 return 0;
1174         } else {
1175                 ASN__CTFAIL(app_key, td, sptr,
1176                         "%s: constraint failed (%s:%d)",
1177                         td->name, __FILE__, __LINE__);
1178                 return -1;
1179         }
1180 }
1181
1182 static int
1183 memb_sixteen_one_constraint_41(const asn_TYPE_descriptor_t *td, const void *sptr,
1184                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1185         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1186         size_t size;
1187
1188         if(!sptr) {
1189                 ASN__CTFAIL(app_key, td, sptr,
1190                         "%s: value not given (%s:%d)",
1191                         td->name, __FILE__, __LINE__);
1192                 return -1;
1193         }
1194
1195         if(st->size > 0) {
1196                 /* Size in bits */
1197                 size = 8 * st->size - (st->bits_unused & 0x07);
1198         } else {
1199                 size = 0;
1200         }
1201
1202         if((size == 128)) {
1203                 /* Constraint check succeeded */
1204                 return 0;
1205         } else {
1206                 ASN__CTFAIL(app_key, td, sptr,
1207                         "%s: constraint failed (%s:%d)",
1208                         td->name, __FILE__, __LINE__);
1209                 return -1;
1210         }
1211 }
1212
1213 static int
1214 memb_typeII_RI_Restriction_constraint_40(const asn_TYPE_descriptor_t *td, const void *sptr,
1215                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1216         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1217         size_t size;
1218
1219         if(!sptr) {
1220                 ASN__CTFAIL(app_key, td, sptr,
1221                         "%s: value not given (%s:%d)",
1222                         td->name, __FILE__, __LINE__);
1223                 return -1;
1224         }
1225
1226         if(st->size > 0) {
1227                 /* Size in bits */
1228                 size = 8 * st->size - (st->bits_unused & 0x07);
1229         } else {
1230                 size = 0;
1231         }
1232
1233         if((size == 2)) {
1234                 /* Constraint check succeeded */
1235                 return 0;
1236         } else {
1237                 ASN__CTFAIL(app_key, td, sptr,
1238                         "%s: constraint failed (%s:%d)",
1239                         td->name, __FILE__, __LINE__);
1240                 return -1;
1241         }
1242 }
1243
1244 /*
1245  * This type is implemented using NativeEnumerated,
1246  * so here we adjust the DEF accordingly.
1247  */
1248 static int
1249 memb_typeII_PortSelectionRI_Restriction_constraint_56(const asn_TYPE_descriptor_t *td, const void *sptr,
1250                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1251         const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
1252         size_t size;
1253
1254         if(!sptr) {
1255                 ASN__CTFAIL(app_key, td, sptr,
1256                         "%s: value not given (%s:%d)",
1257                         td->name, __FILE__, __LINE__);
1258                 return -1;
1259         }
1260
1261         if(st->size > 0) {
1262                 /* Size in bits */
1263                 size = 8 * st->size - (st->bits_unused & 0x07);
1264         } else {
1265                 size = 0;
1266         }
1267
1268         if((size == 2)) {
1269                 /* Constraint check succeeded */
1270                 return 0;
1271         } else {
1272                 ASN__CTFAIL(app_key, td, sptr,
1273                         "%s: constraint failed (%s:%d)",
1274                         td->name, __FILE__, __LINE__);
1275                 return -1;
1276         }
1277 }
1278
1279 /*
1280  * This type is implemented using NativeEnumerated,
1281  * so here we adjust the DEF accordingly.
1282  */
1283 /*
1284  * This type is implemented using NativeEnumerated,
1285  * so here we adjust the DEF accordingly.
1286  */
1287 static asn_oer_constraints_t asn_OER_memb_twoTX_CodebookSubsetRestriction_constr_8 CC_NOTUSED = {
1288         { 0, 0 },
1289         6       /* (SIZE(6..6)) */};
1290 static asn_per_constraints_t asn_PER_memb_twoTX_CodebookSubsetRestriction_constr_8 CC_NOTUSED = {
1291         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1292         { APC_CONSTRAINED,       0,  0,  6,  6 }        /* (SIZE(6..6)) */,
1293         0, 0    /* No PER value map */
1294 };
1295 static asn_oer_constraints_t asn_OER_memb_two_one_TypeI_SinglePanel_Restriction_constr_11 CC_NOTUSED = {
1296         { 0, 0 },
1297         8       /* (SIZE(8..8)) */};
1298 static asn_per_constraints_t asn_PER_memb_two_one_TypeI_SinglePanel_Restriction_constr_11 CC_NOTUSED = {
1299         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1300         { APC_CONSTRAINED,       0,  0,  8,  8 }        /* (SIZE(8..8)) */,
1301         0, 0    /* No PER value map */
1302 };
1303 static asn_oer_constraints_t asn_OER_memb_two_two_TypeI_SinglePanel_Restriction_constr_12 CC_NOTUSED = {
1304         { 0, 0 },
1305         64      /* (SIZE(64..64)) */};
1306 static asn_per_constraints_t asn_PER_memb_two_two_TypeI_SinglePanel_Restriction_constr_12 CC_NOTUSED = {
1307         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1308         { APC_CONSTRAINED,       0,  0,  64,  64 }      /* (SIZE(64..64)) */,
1309         0, 0    /* No PER value map */
1310 };
1311 static asn_oer_constraints_t asn_OER_memb_four_one_TypeI_SinglePanel_Restriction_constr_13 CC_NOTUSED = {
1312         { 0, 0 },
1313         16      /* (SIZE(16..16)) */};
1314 static asn_per_constraints_t asn_PER_memb_four_one_TypeI_SinglePanel_Restriction_constr_13 CC_NOTUSED = {
1315         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1316         { APC_CONSTRAINED,       0,  0,  16,  16 }      /* (SIZE(16..16)) */,
1317         0, 0    /* No PER value map */
1318 };
1319 static asn_oer_constraints_t asn_OER_memb_three_two_TypeI_SinglePanel_Restriction_constr_14 CC_NOTUSED = {
1320         { 0, 0 },
1321         96      /* (SIZE(96..96)) */};
1322 static asn_per_constraints_t asn_PER_memb_three_two_TypeI_SinglePanel_Restriction_constr_14 CC_NOTUSED = {
1323         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1324         { APC_CONSTRAINED,       0,  0,  96,  96 }      /* (SIZE(96..96)) */,
1325         0, 0    /* No PER value map */
1326 };
1327 static asn_oer_constraints_t asn_OER_memb_six_one_TypeI_SinglePanel_Restriction_constr_15 CC_NOTUSED = {
1328         { 0, 0 },
1329         24      /* (SIZE(24..24)) */};
1330 static asn_per_constraints_t asn_PER_memb_six_one_TypeI_SinglePanel_Restriction_constr_15 CC_NOTUSED = {
1331         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1332         { APC_CONSTRAINED,       0,  0,  24,  24 }      /* (SIZE(24..24)) */,
1333         0, 0    /* No PER value map */
1334 };
1335 static asn_oer_constraints_t asn_OER_memb_four_two_TypeI_SinglePanel_Restriction_constr_16 CC_NOTUSED = {
1336         { 0, 0 },
1337         128     /* (SIZE(128..128)) */};
1338 static asn_per_constraints_t asn_PER_memb_four_two_TypeI_SinglePanel_Restriction_constr_16 CC_NOTUSED = {
1339         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1340         { APC_CONSTRAINED,       0,  0,  128,  128 }    /* (SIZE(128..128)) */,
1341         0, 0    /* No PER value map */
1342 };
1343 static asn_oer_constraints_t asn_OER_memb_eight_one_TypeI_SinglePanel_Restriction_constr_17 CC_NOTUSED = {
1344         { 0, 0 },
1345         32      /* (SIZE(32..32)) */};
1346 static asn_per_constraints_t asn_PER_memb_eight_one_TypeI_SinglePanel_Restriction_constr_17 CC_NOTUSED = {
1347         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1348         { APC_CONSTRAINED,       0,  0,  32,  32 }      /* (SIZE(32..32)) */,
1349         0, 0    /* No PER value map */
1350 };
1351 static asn_oer_constraints_t asn_OER_memb_four_three_TypeI_SinglePanel_Restriction_constr_18 CC_NOTUSED = {
1352         { 0, 0 },
1353         192     /* (SIZE(192..192)) */};
1354 static asn_per_constraints_t asn_PER_memb_four_three_TypeI_SinglePanel_Restriction_constr_18 CC_NOTUSED = {
1355         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1356         { APC_CONSTRAINED,       0,  0,  192,  192 }    /* (SIZE(192..192)) */,
1357         0, 0    /* No PER value map */
1358 };
1359 static asn_oer_constraints_t asn_OER_memb_six_two_TypeI_SinglePanel_Restriction_constr_19 CC_NOTUSED = {
1360         { 0, 0 },
1361         192     /* (SIZE(192..192)) */};
1362 static asn_per_constraints_t asn_PER_memb_six_two_TypeI_SinglePanel_Restriction_constr_19 CC_NOTUSED = {
1363         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1364         { APC_CONSTRAINED,       0,  0,  192,  192 }    /* (SIZE(192..192)) */,
1365         0, 0    /* No PER value map */
1366 };
1367 static asn_oer_constraints_t asn_OER_memb_twelve_one_TypeI_SinglePanel_Restriction_constr_20 CC_NOTUSED = {
1368         { 0, 0 },
1369         48      /* (SIZE(48..48)) */};
1370 static asn_per_constraints_t asn_PER_memb_twelve_one_TypeI_SinglePanel_Restriction_constr_20 CC_NOTUSED = {
1371         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1372         { APC_CONSTRAINED,       0,  0,  48,  48 }      /* (SIZE(48..48)) */,
1373         0, 0    /* No PER value map */
1374 };
1375 static asn_oer_constraints_t asn_OER_memb_four_four_TypeI_SinglePanel_Restriction_constr_21 CC_NOTUSED = {
1376         { 0, 0 },
1377         256     /* (SIZE(256..256)) */};
1378 static asn_per_constraints_t asn_PER_memb_four_four_TypeI_SinglePanel_Restriction_constr_21 CC_NOTUSED = {
1379         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1380         { APC_CONSTRAINED,       0,  0,  256,  256 }    /* (SIZE(256..256)) */,
1381         0, 0    /* No PER value map */
1382 };
1383 static asn_oer_constraints_t asn_OER_memb_eight_two_TypeI_SinglePanel_Restriction_constr_22 CC_NOTUSED = {
1384         { 0, 0 },
1385         256     /* (SIZE(256..256)) */};
1386 static asn_per_constraints_t asn_PER_memb_eight_two_TypeI_SinglePanel_Restriction_constr_22 CC_NOTUSED = {
1387         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1388         { APC_CONSTRAINED,       0,  0,  256,  256 }    /* (SIZE(256..256)) */,
1389         0, 0    /* No PER value map */
1390 };
1391 static asn_oer_constraints_t asn_OER_memb_sixteen_one_TypeI_SinglePanel_Restriction_constr_23 CC_NOTUSED = {
1392         { 0, 0 },
1393         64      /* (SIZE(64..64)) */};
1394 static asn_per_constraints_t asn_PER_memb_sixteen_one_TypeI_SinglePanel_Restriction_constr_23 CC_NOTUSED = {
1395         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1396         { APC_CONSTRAINED,       0,  0,  64,  64 }      /* (SIZE(64..64)) */,
1397         0, 0    /* No PER value map */
1398 };
1399 static asn_oer_constraints_t asn_OER_type_n1_n2_constr_10 CC_NOTUSED = {
1400         { 0, 0 },
1401         -1};
1402 static asn_per_constraints_t asn_PER_type_n1_n2_constr_10 CC_NOTUSED = {
1403         { APC_CONSTRAINED,       4,  4,  0,  12 }       /* (0..12) */,
1404         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1405         0, 0    /* No PER value map */
1406 };
1407 static asn_oer_constraints_t asn_OER_memb_typeI_SinglePanel_codebookSubsetRestriction_i2_constr_24 CC_NOTUSED = {
1408         { 0, 0 },
1409         16      /* (SIZE(16..16)) */};
1410 static asn_per_constraints_t asn_PER_memb_typeI_SinglePanel_codebookSubsetRestriction_i2_constr_24 CC_NOTUSED = {
1411         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1412         { APC_CONSTRAINED,       0,  0,  16,  16 }      /* (SIZE(16..16)) */,
1413         0, 0    /* No PER value map */
1414 };
1415 static asn_oer_constraints_t asn_OER_type_nrOfAntennaPorts_constr_6 CC_NOTUSED = {
1416         { 0, 0 },
1417         -1};
1418 static asn_per_constraints_t asn_PER_type_nrOfAntennaPorts_constr_6 CC_NOTUSED = {
1419         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
1420         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1421         0, 0    /* No PER value map */
1422 };
1423 static asn_oer_constraints_t asn_OER_memb_typeI_SinglePanel_ri_Restriction_constr_25 CC_NOTUSED = {
1424         { 0, 0 },
1425         8       /* (SIZE(8..8)) */};
1426 static asn_per_constraints_t asn_PER_memb_typeI_SinglePanel_ri_Restriction_constr_25 CC_NOTUSED = {
1427         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1428         { APC_CONSTRAINED,       0,  0,  8,  8 }        /* (SIZE(8..8)) */,
1429         0, 0    /* No PER value map */
1430 };
1431 static asn_oer_constraints_t asn_OER_memb_two_two_one_TypeI_MultiPanel_Restriction_constr_28 CC_NOTUSED = {
1432         { 0, 0 },
1433         8       /* (SIZE(8..8)) */};
1434 static asn_per_constraints_t asn_PER_memb_two_two_one_TypeI_MultiPanel_Restriction_constr_28 CC_NOTUSED = {
1435         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1436         { APC_CONSTRAINED,       0,  0,  8,  8 }        /* (SIZE(8..8)) */,
1437         0, 0    /* No PER value map */
1438 };
1439 static asn_oer_constraints_t asn_OER_memb_two_four_one_TypeI_MultiPanel_Restriction_constr_29 CC_NOTUSED = {
1440         { 0, 0 },
1441         16      /* (SIZE(16..16)) */};
1442 static asn_per_constraints_t asn_PER_memb_two_four_one_TypeI_MultiPanel_Restriction_constr_29 CC_NOTUSED = {
1443         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1444         { APC_CONSTRAINED,       0,  0,  16,  16 }      /* (SIZE(16..16)) */,
1445         0, 0    /* No PER value map */
1446 };
1447 static asn_oer_constraints_t asn_OER_memb_four_two_one_TypeI_MultiPanel_Restriction_constr_30 CC_NOTUSED = {
1448         { 0, 0 },
1449         8       /* (SIZE(8..8)) */};
1450 static asn_per_constraints_t asn_PER_memb_four_two_one_TypeI_MultiPanel_Restriction_constr_30 CC_NOTUSED = {
1451         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1452         { APC_CONSTRAINED,       0,  0,  8,  8 }        /* (SIZE(8..8)) */,
1453         0, 0    /* No PER value map */
1454 };
1455 static asn_oer_constraints_t asn_OER_memb_two_two_two_TypeI_MultiPanel_Restriction_constr_31 CC_NOTUSED = {
1456         { 0, 0 },
1457         64      /* (SIZE(64..64)) */};
1458 static asn_per_constraints_t asn_PER_memb_two_two_two_TypeI_MultiPanel_Restriction_constr_31 CC_NOTUSED = {
1459         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1460         { APC_CONSTRAINED,       0,  0,  64,  64 }      /* (SIZE(64..64)) */,
1461         0, 0    /* No PER value map */
1462 };
1463 static asn_oer_constraints_t asn_OER_memb_two_eight_one_TypeI_MultiPanel_Restriction_constr_32 CC_NOTUSED = {
1464         { 0, 0 },
1465         32      /* (SIZE(32..32)) */};
1466 static asn_per_constraints_t asn_PER_memb_two_eight_one_TypeI_MultiPanel_Restriction_constr_32 CC_NOTUSED = {
1467         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1468         { APC_CONSTRAINED,       0,  0,  32,  32 }      /* (SIZE(32..32)) */,
1469         0, 0    /* No PER value map */
1470 };
1471 static asn_oer_constraints_t asn_OER_memb_four_four_one_TypeI_MultiPanel_Restriction_constr_33 CC_NOTUSED = {
1472         { 0, 0 },
1473         16      /* (SIZE(16..16)) */};
1474 static asn_per_constraints_t asn_PER_memb_four_four_one_TypeI_MultiPanel_Restriction_constr_33 CC_NOTUSED = {
1475         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1476         { APC_CONSTRAINED,       0,  0,  16,  16 }      /* (SIZE(16..16)) */,
1477         0, 0    /* No PER value map */
1478 };
1479 static asn_oer_constraints_t asn_OER_memb_two_four_two_TypeI_MultiPanel_Restriction_constr_34 CC_NOTUSED = {
1480         { 0, 0 },
1481         128     /* (SIZE(128..128)) */};
1482 static asn_per_constraints_t asn_PER_memb_two_four_two_TypeI_MultiPanel_Restriction_constr_34 CC_NOTUSED = {
1483         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1484         { APC_CONSTRAINED,       0,  0,  128,  128 }    /* (SIZE(128..128)) */,
1485         0, 0    /* No PER value map */
1486 };
1487 static asn_oer_constraints_t asn_OER_memb_four_two_two_TypeI_MultiPanel_Restriction_constr_35 CC_NOTUSED = {
1488         { 0, 0 },
1489         64      /* (SIZE(64..64)) */};
1490 static asn_per_constraints_t asn_PER_memb_four_two_two_TypeI_MultiPanel_Restriction_constr_35 CC_NOTUSED = {
1491         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1492         { APC_CONSTRAINED,       0,  0,  64,  64 }      /* (SIZE(64..64)) */,
1493         0, 0    /* No PER value map */
1494 };
1495 static asn_oer_constraints_t asn_OER_type_ng_n1_n2_constr_27 CC_NOTUSED = {
1496         { 0, 0 },
1497         -1};
1498 static asn_per_constraints_t asn_PER_type_ng_n1_n2_constr_27 CC_NOTUSED = {
1499         { APC_CONSTRAINED,       3,  3,  0,  7 }        /* (0..7) */,
1500         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1501         0, 0    /* No PER value map */
1502 };
1503 static asn_oer_constraints_t asn_OER_memb_ri_Restriction_constr_36 CC_NOTUSED = {
1504         { 0, 0 },
1505         4       /* (SIZE(4..4)) */};
1506 static asn_per_constraints_t asn_PER_memb_ri_Restriction_constr_36 CC_NOTUSED = {
1507         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1508         { APC_CONSTRAINED,       0,  0,  4,  4 }        /* (SIZE(4..4)) */,
1509         0, 0    /* No PER value map */
1510 };
1511 static asn_oer_constraints_t asn_OER_type_subType_constr_4 CC_NOTUSED = {
1512         { 0, 0 },
1513         -1};
1514 static asn_per_constraints_t asn_PER_type_subType_constr_4 CC_NOTUSED = {
1515         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
1516         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1517         0, 0    /* No PER value map */
1518 };
1519 static asn_oer_constraints_t asn_OER_memb_codebookMode_constr_37 CC_NOTUSED = {
1520         { 1, 1 }        /* (1..2) */,
1521         -1};
1522 static asn_per_constraints_t asn_PER_memb_codebookMode_constr_37 CC_NOTUSED = {
1523         { APC_CONSTRAINED,       1,  1,  1,  2 }        /* (1..2) */,
1524         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1525         0, 0    /* No PER value map */
1526 };
1527 static asn_oer_constraints_t asn_OER_memb_two_one_constr_42 CC_NOTUSED = {
1528         { 0, 0 },
1529         16      /* (SIZE(16..16)) */};
1530 static asn_per_constraints_t asn_PER_memb_two_one_constr_42 CC_NOTUSED = {
1531         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1532         { APC_CONSTRAINED,       0,  0,  16,  16 }      /* (SIZE(16..16)) */,
1533         0, 0    /* No PER value map */
1534 };
1535 static asn_oer_constraints_t asn_OER_memb_two_two_constr_43 CC_NOTUSED = {
1536         { 0, 0 },
1537         43      /* (SIZE(43..43)) */};
1538 static asn_per_constraints_t asn_PER_memb_two_two_constr_43 CC_NOTUSED = {
1539         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1540         { APC_CONSTRAINED,       0,  0,  43,  43 }      /* (SIZE(43..43)) */,
1541         0, 0    /* No PER value map */
1542 };
1543 static asn_oer_constraints_t asn_OER_memb_four_one_constr_44 CC_NOTUSED = {
1544         { 0, 0 },
1545         32      /* (SIZE(32..32)) */};
1546 static asn_per_constraints_t asn_PER_memb_four_one_constr_44 CC_NOTUSED = {
1547         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1548         { APC_CONSTRAINED,       0,  0,  32,  32 }      /* (SIZE(32..32)) */,
1549         0, 0    /* No PER value map */
1550 };
1551 static asn_oer_constraints_t asn_OER_memb_three_two_constr_45 CC_NOTUSED = {
1552         { 0, 0 },
1553         59      /* (SIZE(59..59)) */};
1554 static asn_per_constraints_t asn_PER_memb_three_two_constr_45 CC_NOTUSED = {
1555         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1556         { APC_CONSTRAINED,       0,  0,  59,  59 }      /* (SIZE(59..59)) */,
1557         0, 0    /* No PER value map */
1558 };
1559 static asn_oer_constraints_t asn_OER_memb_six_one_constr_46 CC_NOTUSED = {
1560         { 0, 0 },
1561         48      /* (SIZE(48..48)) */};
1562 static asn_per_constraints_t asn_PER_memb_six_one_constr_46 CC_NOTUSED = {
1563         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1564         { APC_CONSTRAINED,       0,  0,  48,  48 }      /* (SIZE(48..48)) */,
1565         0, 0    /* No PER value map */
1566 };
1567 static asn_oer_constraints_t asn_OER_memb_four_two_constr_47 CC_NOTUSED = {
1568         { 0, 0 },
1569         75      /* (SIZE(75..75)) */};
1570 static asn_per_constraints_t asn_PER_memb_four_two_constr_47 CC_NOTUSED = {
1571         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1572         { APC_CONSTRAINED,       0,  0,  75,  75 }      /* (SIZE(75..75)) */,
1573         0, 0    /* No PER value map */
1574 };
1575 static asn_oer_constraints_t asn_OER_memb_eight_one_constr_48 CC_NOTUSED = {
1576         { 0, 0 },
1577         64      /* (SIZE(64..64)) */};
1578 static asn_per_constraints_t asn_PER_memb_eight_one_constr_48 CC_NOTUSED = {
1579         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1580         { APC_CONSTRAINED,       0,  0,  64,  64 }      /* (SIZE(64..64)) */,
1581         0, 0    /* No PER value map */
1582 };
1583 static asn_oer_constraints_t asn_OER_memb_four_three_constr_49 CC_NOTUSED = {
1584         { 0, 0 },
1585         107     /* (SIZE(107..107)) */};
1586 static asn_per_constraints_t asn_PER_memb_four_three_constr_49 CC_NOTUSED = {
1587         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1588         { APC_CONSTRAINED,       0,  0,  107,  107 }    /* (SIZE(107..107)) */,
1589         0, 0    /* No PER value map */
1590 };
1591 static asn_oer_constraints_t asn_OER_memb_six_two_constr_50 CC_NOTUSED = {
1592         { 0, 0 },
1593         107     /* (SIZE(107..107)) */};
1594 static asn_per_constraints_t asn_PER_memb_six_two_constr_50 CC_NOTUSED = {
1595         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1596         { APC_CONSTRAINED,       0,  0,  107,  107 }    /* (SIZE(107..107)) */,
1597         0, 0    /* No PER value map */
1598 };
1599 static asn_oer_constraints_t asn_OER_memb_twelve_one_constr_51 CC_NOTUSED = {
1600         { 0, 0 },
1601         96      /* (SIZE(96..96)) */};
1602 static asn_per_constraints_t asn_PER_memb_twelve_one_constr_51 CC_NOTUSED = {
1603         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1604         { APC_CONSTRAINED,       0,  0,  96,  96 }      /* (SIZE(96..96)) */,
1605         0, 0    /* No PER value map */
1606 };
1607 static asn_oer_constraints_t asn_OER_memb_four_four_constr_52 CC_NOTUSED = {
1608         { 0, 0 },
1609         139     /* (SIZE(139..139)) */};
1610 static asn_per_constraints_t asn_PER_memb_four_four_constr_52 CC_NOTUSED = {
1611         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1612         { APC_CONSTRAINED,       0,  0,  139,  139 }    /* (SIZE(139..139)) */,
1613         0, 0    /* No PER value map */
1614 };
1615 static asn_oer_constraints_t asn_OER_memb_eight_two_constr_53 CC_NOTUSED = {
1616         { 0, 0 },
1617         139     /* (SIZE(139..139)) */};
1618 static asn_per_constraints_t asn_PER_memb_eight_two_constr_53 CC_NOTUSED = {
1619         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1620         { APC_CONSTRAINED,       0,  0,  139,  139 }    /* (SIZE(139..139)) */,
1621         0, 0    /* No PER value map */
1622 };
1623 static asn_oer_constraints_t asn_OER_memb_sixteen_one_constr_54 CC_NOTUSED = {
1624         { 0, 0 },
1625         128     /* (SIZE(128..128)) */};
1626 static asn_per_constraints_t asn_PER_memb_sixteen_one_constr_54 CC_NOTUSED = {
1627         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1628         { APC_CONSTRAINED,       0,  0,  128,  128 }    /* (SIZE(128..128)) */,
1629         0, 0    /* No PER value map */
1630 };
1631 static asn_oer_constraints_t asn_OER_type_n1_n2_codebookSubsetRestriction_constr_41 CC_NOTUSED = {
1632         { 0, 0 },
1633         -1};
1634 static asn_per_constraints_t asn_PER_type_n1_n2_codebookSubsetRestriction_constr_41 CC_NOTUSED = {
1635         { APC_CONSTRAINED,       4,  4,  0,  12 }       /* (0..12) */,
1636         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1637         0, 0    /* No PER value map */
1638 };
1639 static asn_oer_constraints_t asn_OER_memb_typeII_RI_Restriction_constr_55 CC_NOTUSED = {
1640         { 0, 0 },
1641         2       /* (SIZE(2..2)) */};
1642 static asn_per_constraints_t asn_PER_memb_typeII_RI_Restriction_constr_55 CC_NOTUSED = {
1643         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1644         { APC_CONSTRAINED,       0,  0,  2,  2 }        /* (SIZE(2..2)) */,
1645         0, 0    /* No PER value map */
1646 };
1647 static asn_oer_constraints_t asn_OER_type_portSelectionSamplingSize_constr_57 CC_NOTUSED = {
1648         { 0, 0 },
1649         -1};
1650 static asn_per_constraints_t asn_PER_type_portSelectionSamplingSize_constr_57 CC_NOTUSED = {
1651         { APC_CONSTRAINED,       2,  2,  0,  3 }        /* (0..3) */,
1652         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1653         0, 0    /* No PER value map */
1654 };
1655 static asn_oer_constraints_t asn_OER_memb_typeII_PortSelectionRI_Restriction_constr_62 CC_NOTUSED = {
1656         { 0, 0 },
1657         2       /* (SIZE(2..2)) */};
1658 static asn_per_constraints_t asn_PER_memb_typeII_PortSelectionRI_Restriction_constr_62 CC_NOTUSED = {
1659         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1660         { APC_CONSTRAINED,       0,  0,  2,  2 }        /* (SIZE(2..2)) */,
1661         0, 0    /* No PER value map */
1662 };
1663 static asn_oer_constraints_t asn_OER_type_subType_constr_39 CC_NOTUSED = {
1664         { 0, 0 },
1665         -1};
1666 static asn_per_constraints_t asn_PER_type_subType_constr_39 CC_NOTUSED = {
1667         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
1668         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1669         0, 0    /* No PER value map */
1670 };
1671 static asn_oer_constraints_t asn_OER_type_phaseAlphabetSize_constr_63 CC_NOTUSED = {
1672         { 0, 0 },
1673         -1};
1674 static asn_per_constraints_t asn_PER_type_phaseAlphabetSize_constr_63 CC_NOTUSED = {
1675         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
1676         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1677         0, 0    /* No PER value map */
1678 };
1679 static asn_oer_constraints_t asn_OER_type_numberOfBeams_constr_67 CC_NOTUSED = {
1680         { 0, 0 },
1681         -1};
1682 static asn_per_constraints_t asn_PER_type_numberOfBeams_constr_67 CC_NOTUSED = {
1683         { APC_CONSTRAINED,       2,  2,  0,  2 }        /* (0..2) */,
1684         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1685         0, 0    /* No PER value map */
1686 };
1687 static asn_oer_constraints_t asn_OER_type_codebookType_constr_2 CC_NOTUSED = {
1688         { 0, 0 },
1689         -1};
1690 static asn_per_constraints_t asn_PER_type_codebookType_constr_2 CC_NOTUSED = {
1691         { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
1692         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1693         0, 0    /* No PER value map */
1694 };
1695 static asn_TYPE_member_t asn_MBR_two_7[] = {
1696         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__two, twoTX_CodebookSubsetRestriction),
1697                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1698                 -1,     /* IMPLICIT tag at current level */
1699                 &asn_DEF_BIT_STRING,
1700                 0,
1701                 { &asn_OER_memb_twoTX_CodebookSubsetRestriction_constr_8, &asn_PER_memb_twoTX_CodebookSubsetRestriction_constr_8,  memb_twoTX_CodebookSubsetRestriction_constraint_7 },
1702                 0, 0, /* No default value */
1703                 "twoTX-CodebookSubsetRestriction"
1704                 },
1705 };
1706 static const ber_tlv_tag_t asn_DEF_two_tags_7[] = {
1707         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1708         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1709 };
1710 static const asn_TYPE_tag2member_t asn_MAP_two_tag2el_7[] = {
1711     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* twoTX-CodebookSubsetRestriction */
1712 };
1713 static asn_SEQUENCE_specifics_t asn_SPC_two_specs_7 = {
1714         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__two),
1715         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__two, _asn_ctx),
1716         asn_MAP_two_tag2el_7,
1717         1,      /* Count of tags in the map */
1718         0, 0, 0,        /* Optional elements (not needed) */
1719         -1,     /* First extension addition */
1720 };
1721 static /* Use -fall-defs-global to expose */
1722 asn_TYPE_descriptor_t asn_DEF_two_7 = {
1723         "two",
1724         "two",
1725         &asn_OP_SEQUENCE,
1726         asn_DEF_two_tags_7,
1727         sizeof(asn_DEF_two_tags_7)
1728                 /sizeof(asn_DEF_two_tags_7[0]) - 1, /* 1 */
1729         asn_DEF_two_tags_7,     /* Same as above */
1730         sizeof(asn_DEF_two_tags_7)
1731                 /sizeof(asn_DEF_two_tags_7[0]), /* 2 */
1732         { 0, 0, SEQUENCE_constraint },
1733         asn_MBR_two_7,
1734         1,      /* Elements count */
1735         &asn_SPC_two_specs_7    /* Additional specs */
1736 };
1737
1738 static asn_TYPE_member_t asn_MBR_n1_n2_10[] = {
1739         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.two_one_TypeI_SinglePanel_Restriction),
1740                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1741                 -1,     /* IMPLICIT tag at current level */
1742                 &asn_DEF_BIT_STRING,
1743                 0,
1744                 { &asn_OER_memb_two_one_TypeI_SinglePanel_Restriction_constr_11, &asn_PER_memb_two_one_TypeI_SinglePanel_Restriction_constr_11,  memb_two_one_TypeI_SinglePanel_Restriction_constraint_10 },
1745                 0, 0, /* No default value */
1746                 "two-one-TypeI-SinglePanel-Restriction"
1747                 },
1748         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.two_two_TypeI_SinglePanel_Restriction),
1749                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1750                 -1,     /* IMPLICIT tag at current level */
1751                 &asn_DEF_BIT_STRING,
1752                 0,
1753                 { &asn_OER_memb_two_two_TypeI_SinglePanel_Restriction_constr_12, &asn_PER_memb_two_two_TypeI_SinglePanel_Restriction_constr_12,  memb_two_two_TypeI_SinglePanel_Restriction_constraint_10 },
1754                 0, 0, /* No default value */
1755                 "two-two-TypeI-SinglePanel-Restriction"
1756                 },
1757         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.four_one_TypeI_SinglePanel_Restriction),
1758                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
1759                 -1,     /* IMPLICIT tag at current level */
1760                 &asn_DEF_BIT_STRING,
1761                 0,
1762                 { &asn_OER_memb_four_one_TypeI_SinglePanel_Restriction_constr_13, &asn_PER_memb_four_one_TypeI_SinglePanel_Restriction_constr_13,  memb_four_one_TypeI_SinglePanel_Restriction_constraint_10 },
1763                 0, 0, /* No default value */
1764                 "four-one-TypeI-SinglePanel-Restriction"
1765                 },
1766         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.three_two_TypeI_SinglePanel_Restriction),
1767                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
1768                 -1,     /* IMPLICIT tag at current level */
1769                 &asn_DEF_BIT_STRING,
1770                 0,
1771                 { &asn_OER_memb_three_two_TypeI_SinglePanel_Restriction_constr_14, &asn_PER_memb_three_two_TypeI_SinglePanel_Restriction_constr_14,  memb_three_two_TypeI_SinglePanel_Restriction_constraint_10 },
1772                 0, 0, /* No default value */
1773                 "three-two-TypeI-SinglePanel-Restriction"
1774                 },
1775         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.six_one_TypeI_SinglePanel_Restriction),
1776                 (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
1777                 -1,     /* IMPLICIT tag at current level */
1778                 &asn_DEF_BIT_STRING,
1779                 0,
1780                 { &asn_OER_memb_six_one_TypeI_SinglePanel_Restriction_constr_15, &asn_PER_memb_six_one_TypeI_SinglePanel_Restriction_constr_15,  memb_six_one_TypeI_SinglePanel_Restriction_constraint_10 },
1781                 0, 0, /* No default value */
1782                 "six-one-TypeI-SinglePanel-Restriction"
1783                 },
1784         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.four_two_TypeI_SinglePanel_Restriction),
1785                 (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
1786                 -1,     /* IMPLICIT tag at current level */
1787                 &asn_DEF_BIT_STRING,
1788                 0,
1789                 { &asn_OER_memb_four_two_TypeI_SinglePanel_Restriction_constr_16, &asn_PER_memb_four_two_TypeI_SinglePanel_Restriction_constr_16,  memb_four_two_TypeI_SinglePanel_Restriction_constraint_10 },
1790                 0, 0, /* No default value */
1791                 "four-two-TypeI-SinglePanel-Restriction"
1792                 },
1793         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.eight_one_TypeI_SinglePanel_Restriction),
1794                 (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
1795                 -1,     /* IMPLICIT tag at current level */
1796                 &asn_DEF_BIT_STRING,
1797                 0,
1798                 { &asn_OER_memb_eight_one_TypeI_SinglePanel_Restriction_constr_17, &asn_PER_memb_eight_one_TypeI_SinglePanel_Restriction_constr_17,  memb_eight_one_TypeI_SinglePanel_Restriction_constraint_10 },
1799                 0, 0, /* No default value */
1800                 "eight-one-TypeI-SinglePanel-Restriction"
1801                 },
1802         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.four_three_TypeI_SinglePanel_Restriction),
1803                 (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
1804                 -1,     /* IMPLICIT tag at current level */
1805                 &asn_DEF_BIT_STRING,
1806                 0,
1807                 { &asn_OER_memb_four_three_TypeI_SinglePanel_Restriction_constr_18, &asn_PER_memb_four_three_TypeI_SinglePanel_Restriction_constr_18,  memb_four_three_TypeI_SinglePanel_Restriction_constraint_10 },
1808                 0, 0, /* No default value */
1809                 "four-three-TypeI-SinglePanel-Restriction"
1810                 },
1811         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.six_two_TypeI_SinglePanel_Restriction),
1812                 (ASN_TAG_CLASS_CONTEXT | (8 << 2)),
1813                 -1,     /* IMPLICIT tag at current level */
1814                 &asn_DEF_BIT_STRING,
1815                 0,
1816                 { &asn_OER_memb_six_two_TypeI_SinglePanel_Restriction_constr_19, &asn_PER_memb_six_two_TypeI_SinglePanel_Restriction_constr_19,  memb_six_two_TypeI_SinglePanel_Restriction_constraint_10 },
1817                 0, 0, /* No default value */
1818                 "six-two-TypeI-SinglePanel-Restriction"
1819                 },
1820         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.twelve_one_TypeI_SinglePanel_Restriction),
1821                 (ASN_TAG_CLASS_CONTEXT | (9 << 2)),
1822                 -1,     /* IMPLICIT tag at current level */
1823                 &asn_DEF_BIT_STRING,
1824                 0,
1825                 { &asn_OER_memb_twelve_one_TypeI_SinglePanel_Restriction_constr_20, &asn_PER_memb_twelve_one_TypeI_SinglePanel_Restriction_constr_20,  memb_twelve_one_TypeI_SinglePanel_Restriction_constraint_10 },
1826                 0, 0, /* No default value */
1827                 "twelve-one-TypeI-SinglePanel-Restriction"
1828                 },
1829         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.four_four_TypeI_SinglePanel_Restriction),
1830                 (ASN_TAG_CLASS_CONTEXT | (10 << 2)),
1831                 -1,     /* IMPLICIT tag at current level */
1832                 &asn_DEF_BIT_STRING,
1833                 0,
1834                 { &asn_OER_memb_four_four_TypeI_SinglePanel_Restriction_constr_21, &asn_PER_memb_four_four_TypeI_SinglePanel_Restriction_constr_21,  memb_four_four_TypeI_SinglePanel_Restriction_constraint_10 },
1835                 0, 0, /* No default value */
1836                 "four-four-TypeI-SinglePanel-Restriction"
1837                 },
1838         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.eight_two_TypeI_SinglePanel_Restriction),
1839                 (ASN_TAG_CLASS_CONTEXT | (11 << 2)),
1840                 -1,     /* IMPLICIT tag at current level */
1841                 &asn_DEF_BIT_STRING,
1842                 0,
1843                 { &asn_OER_memb_eight_two_TypeI_SinglePanel_Restriction_constr_22, &asn_PER_memb_eight_two_TypeI_SinglePanel_Restriction_constr_22,  memb_eight_two_TypeI_SinglePanel_Restriction_constraint_10 },
1844                 0, 0, /* No default value */
1845                 "eight-two-TypeI-SinglePanel-Restriction"
1846                 },
1847         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, choice.sixteen_one_TypeI_SinglePanel_Restriction),
1848                 (ASN_TAG_CLASS_CONTEXT | (12 << 2)),
1849                 -1,     /* IMPLICIT tag at current level */
1850                 &asn_DEF_BIT_STRING,
1851                 0,
1852                 { &asn_OER_memb_sixteen_one_TypeI_SinglePanel_Restriction_constr_23, &asn_PER_memb_sixteen_one_TypeI_SinglePanel_Restriction_constr_23,  memb_sixteen_one_TypeI_SinglePanel_Restriction_constraint_10 },
1853                 0, 0, /* No default value */
1854                 "sixteen-one-TypeI-SinglePanel-Restriction"
1855                 },
1856 };
1857 static const asn_TYPE_tag2member_t asn_MAP_n1_n2_tag2el_10[] = {
1858     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* two-one-TypeI-SinglePanel-Restriction */
1859     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* two-two-TypeI-SinglePanel-Restriction */
1860     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* four-one-TypeI-SinglePanel-Restriction */
1861     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* three-two-TypeI-SinglePanel-Restriction */
1862     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* six-one-TypeI-SinglePanel-Restriction */
1863     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* four-two-TypeI-SinglePanel-Restriction */
1864     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* eight-one-TypeI-SinglePanel-Restriction */
1865     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* four-three-TypeI-SinglePanel-Restriction */
1866     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* six-two-TypeI-SinglePanel-Restriction */
1867     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* twelve-one-TypeI-SinglePanel-Restriction */
1868     { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* four-four-TypeI-SinglePanel-Restriction */
1869     { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 }, /* eight-two-TypeI-SinglePanel-Restriction */
1870     { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 12, 0, 0 } /* sixteen-one-TypeI-SinglePanel-Restriction */
1871 };
1872 static asn_CHOICE_specifics_t asn_SPC_n1_n2_specs_10 = {
1873         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2),
1874         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, _asn_ctx),
1875         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2, present),
1876         sizeof(((struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo__n1_n2 *)0)->present),
1877         asn_MAP_n1_n2_tag2el_10,
1878         13,     /* Count of tags in the map */
1879         0, 0,
1880         -1      /* Extensions start */
1881 };
1882 static /* Use -fall-defs-global to expose */
1883 asn_TYPE_descriptor_t asn_DEF_n1_n2_10 = {
1884         "n1-n2",
1885         "n1-n2",
1886         &asn_OP_CHOICE,
1887         0,      /* No effective tags (pointer) */
1888         0,      /* No effective tags (count) */
1889         0,      /* No tags (pointer) */
1890         0,      /* No tags (count) */
1891         { &asn_OER_type_n1_n2_constr_10, &asn_PER_type_n1_n2_constr_10, CHOICE_constraint },
1892         asn_MBR_n1_n2_10,
1893         13,     /* Elements count */
1894         &asn_SPC_n1_n2_specs_10 /* Additional specs */
1895 };
1896
1897 static asn_TYPE_member_t asn_MBR_moreThanTwo_9[] = {
1898         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo, n1_n2),
1899                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1900                 +1,     /* EXPLICIT tag at current level */
1901                 &asn_DEF_n1_n2_10,
1902                 0,
1903                 { 0, 0, 0 },
1904                 0, 0, /* No default value */
1905                 "n1-n2"
1906                 },
1907         { ATF_POINTER, 1, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo, typeI_SinglePanel_codebookSubsetRestriction_i2),
1908                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1909                 -1,     /* IMPLICIT tag at current level */
1910                 &asn_DEF_BIT_STRING,
1911                 0,
1912                 { &asn_OER_memb_typeI_SinglePanel_codebookSubsetRestriction_i2_constr_24, &asn_PER_memb_typeI_SinglePanel_codebookSubsetRestriction_i2_constr_24,  memb_typeI_SinglePanel_codebookSubsetRestriction_i2_constraint_9 },
1913                 0, 0, /* No default value */
1914                 "typeI-SinglePanel-codebookSubsetRestriction-i2"
1915                 },
1916 };
1917 static const int asn_MAP_moreThanTwo_oms_9[] = { 1 };
1918 static const ber_tlv_tag_t asn_DEF_moreThanTwo_tags_9[] = {
1919         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1920         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1921 };
1922 static const asn_TYPE_tag2member_t asn_MAP_moreThanTwo_tag2el_9[] = {
1923     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* n1-n2 */
1924     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* typeI-SinglePanel-codebookSubsetRestriction-i2 */
1925 };
1926 static asn_SEQUENCE_specifics_t asn_SPC_moreThanTwo_specs_9 = {
1927         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo),
1928         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts__moreThanTwo, _asn_ctx),
1929         asn_MAP_moreThanTwo_tag2el_9,
1930         2,      /* Count of tags in the map */
1931         asn_MAP_moreThanTwo_oms_9,      /* Optional members */
1932         1, 0,   /* Root/Additions */
1933         -1,     /* First extension addition */
1934 };
1935 static /* Use -fall-defs-global to expose */
1936 asn_TYPE_descriptor_t asn_DEF_moreThanTwo_9 = {
1937         "moreThanTwo",
1938         "moreThanTwo",
1939         &asn_OP_SEQUENCE,
1940         asn_DEF_moreThanTwo_tags_9,
1941         sizeof(asn_DEF_moreThanTwo_tags_9)
1942                 /sizeof(asn_DEF_moreThanTwo_tags_9[0]) - 1, /* 1 */
1943         asn_DEF_moreThanTwo_tags_9,     /* Same as above */
1944         sizeof(asn_DEF_moreThanTwo_tags_9)
1945                 /sizeof(asn_DEF_moreThanTwo_tags_9[0]), /* 2 */
1946         { 0, 0, SEQUENCE_constraint },
1947         asn_MBR_moreThanTwo_9,
1948         2,      /* Elements count */
1949         &asn_SPC_moreThanTwo_specs_9    /* Additional specs */
1950 };
1951
1952 static asn_TYPE_member_t asn_MBR_nrOfAntennaPorts_6[] = {
1953         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts, choice.two),
1954                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1955                 0,
1956                 &asn_DEF_two_7,
1957                 0,
1958                 { 0, 0, 0 },
1959                 0, 0, /* No default value */
1960                 "two"
1961                 },
1962         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts, choice.moreThanTwo),
1963                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1964                 0,
1965                 &asn_DEF_moreThanTwo_9,
1966                 0,
1967                 { 0, 0, 0 },
1968                 0, 0, /* No default value */
1969                 "moreThanTwo"
1970                 },
1971 };
1972 static const asn_TYPE_tag2member_t asn_MAP_nrOfAntennaPorts_tag2el_6[] = {
1973     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* two */
1974     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* moreThanTwo */
1975 };
1976 static asn_CHOICE_specifics_t asn_SPC_nrOfAntennaPorts_specs_6 = {
1977         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts),
1978         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts, _asn_ctx),
1979         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts, present),
1980         sizeof(((struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel__nrOfAntennaPorts *)0)->present),
1981         asn_MAP_nrOfAntennaPorts_tag2el_6,
1982         2,      /* Count of tags in the map */
1983         0, 0,
1984         -1      /* Extensions start */
1985 };
1986 static /* Use -fall-defs-global to expose */
1987 asn_TYPE_descriptor_t asn_DEF_nrOfAntennaPorts_6 = {
1988         "nrOfAntennaPorts",
1989         "nrOfAntennaPorts",
1990         &asn_OP_CHOICE,
1991         0,      /* No effective tags (pointer) */
1992         0,      /* No effective tags (count) */
1993         0,      /* No tags (pointer) */
1994         0,      /* No tags (count) */
1995         { &asn_OER_type_nrOfAntennaPorts_constr_6, &asn_PER_type_nrOfAntennaPorts_constr_6, CHOICE_constraint },
1996         asn_MBR_nrOfAntennaPorts_6,
1997         2,      /* Elements count */
1998         &asn_SPC_nrOfAntennaPorts_specs_6       /* Additional specs */
1999 };
2000
2001 static asn_TYPE_member_t asn_MBR_typeI_SinglePanel_5[] = {
2002         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel, nrOfAntennaPorts),
2003                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2004                 +1,     /* EXPLICIT tag at current level */
2005                 &asn_DEF_nrOfAntennaPorts_6,
2006                 0,
2007                 { 0, 0, 0 },
2008                 0, 0, /* No default value */
2009                 "nrOfAntennaPorts"
2010                 },
2011         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel, typeI_SinglePanel_ri_Restriction),
2012                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2013                 -1,     /* IMPLICIT tag at current level */
2014                 &asn_DEF_BIT_STRING,
2015                 0,
2016                 { &asn_OER_memb_typeI_SinglePanel_ri_Restriction_constr_25, &asn_PER_memb_typeI_SinglePanel_ri_Restriction_constr_25,  memb_typeI_SinglePanel_ri_Restriction_constraint_5 },
2017                 0, 0, /* No default value */
2018                 "typeI-SinglePanel-ri-Restriction"
2019                 },
2020 };
2021 static const ber_tlv_tag_t asn_DEF_typeI_SinglePanel_tags_5[] = {
2022         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2023         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2024 };
2025 static const asn_TYPE_tag2member_t asn_MAP_typeI_SinglePanel_tag2el_5[] = {
2026     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* nrOfAntennaPorts */
2027     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* typeI-SinglePanel-ri-Restriction */
2028 };
2029 static asn_SEQUENCE_specifics_t asn_SPC_typeI_SinglePanel_specs_5 = {
2030         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel),
2031         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_SinglePanel, _asn_ctx),
2032         asn_MAP_typeI_SinglePanel_tag2el_5,
2033         2,      /* Count of tags in the map */
2034         0, 0, 0,        /* Optional elements (not needed) */
2035         -1,     /* First extension addition */
2036 };
2037 static /* Use -fall-defs-global to expose */
2038 asn_TYPE_descriptor_t asn_DEF_typeI_SinglePanel_5 = {
2039         "typeI-SinglePanel",
2040         "typeI-SinglePanel",
2041         &asn_OP_SEQUENCE,
2042         asn_DEF_typeI_SinglePanel_tags_5,
2043         sizeof(asn_DEF_typeI_SinglePanel_tags_5)
2044                 /sizeof(asn_DEF_typeI_SinglePanel_tags_5[0]) - 1, /* 1 */
2045         asn_DEF_typeI_SinglePanel_tags_5,       /* Same as above */
2046         sizeof(asn_DEF_typeI_SinglePanel_tags_5)
2047                 /sizeof(asn_DEF_typeI_SinglePanel_tags_5[0]), /* 2 */
2048         { 0, 0, SEQUENCE_constraint },
2049         asn_MBR_typeI_SinglePanel_5,
2050         2,      /* Elements count */
2051         &asn_SPC_typeI_SinglePanel_specs_5      /* Additional specs */
2052 };
2053
2054 static asn_TYPE_member_t asn_MBR_ng_n1_n2_27[] = {
2055         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.two_two_one_TypeI_MultiPanel_Restriction),
2056                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2057                 -1,     /* IMPLICIT tag at current level */
2058                 &asn_DEF_BIT_STRING,
2059                 0,
2060                 { &asn_OER_memb_two_two_one_TypeI_MultiPanel_Restriction_constr_28, &asn_PER_memb_two_two_one_TypeI_MultiPanel_Restriction_constr_28,  memb_two_two_one_TypeI_MultiPanel_Restriction_constraint_27 },
2061                 0, 0, /* No default value */
2062                 "two-two-one-TypeI-MultiPanel-Restriction"
2063                 },
2064         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.two_four_one_TypeI_MultiPanel_Restriction),
2065                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2066                 -1,     /* IMPLICIT tag at current level */
2067                 &asn_DEF_BIT_STRING,
2068                 0,
2069                 { &asn_OER_memb_two_four_one_TypeI_MultiPanel_Restriction_constr_29, &asn_PER_memb_two_four_one_TypeI_MultiPanel_Restriction_constr_29,  memb_two_four_one_TypeI_MultiPanel_Restriction_constraint_27 },
2070                 0, 0, /* No default value */
2071                 "two-four-one-TypeI-MultiPanel-Restriction"
2072                 },
2073         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.four_two_one_TypeI_MultiPanel_Restriction),
2074                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
2075                 -1,     /* IMPLICIT tag at current level */
2076                 &asn_DEF_BIT_STRING,
2077                 0,
2078                 { &asn_OER_memb_four_two_one_TypeI_MultiPanel_Restriction_constr_30, &asn_PER_memb_four_two_one_TypeI_MultiPanel_Restriction_constr_30,  memb_four_two_one_TypeI_MultiPanel_Restriction_constraint_27 },
2079                 0, 0, /* No default value */
2080                 "four-two-one-TypeI-MultiPanel-Restriction"
2081                 },
2082         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.two_two_two_TypeI_MultiPanel_Restriction),
2083                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
2084                 -1,     /* IMPLICIT tag at current level */
2085                 &asn_DEF_BIT_STRING,
2086                 0,
2087                 { &asn_OER_memb_two_two_two_TypeI_MultiPanel_Restriction_constr_31, &asn_PER_memb_two_two_two_TypeI_MultiPanel_Restriction_constr_31,  memb_two_two_two_TypeI_MultiPanel_Restriction_constraint_27 },
2088                 0, 0, /* No default value */
2089                 "two-two-two-TypeI-MultiPanel-Restriction"
2090                 },
2091         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.two_eight_one_TypeI_MultiPanel_Restriction),
2092                 (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
2093                 -1,     /* IMPLICIT tag at current level */
2094                 &asn_DEF_BIT_STRING,
2095                 0,
2096                 { &asn_OER_memb_two_eight_one_TypeI_MultiPanel_Restriction_constr_32, &asn_PER_memb_two_eight_one_TypeI_MultiPanel_Restriction_constr_32,  memb_two_eight_one_TypeI_MultiPanel_Restriction_constraint_27 },
2097                 0, 0, /* No default value */
2098                 "two-eight-one-TypeI-MultiPanel-Restriction"
2099                 },
2100         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.four_four_one_TypeI_MultiPanel_Restriction),
2101                 (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
2102                 -1,     /* IMPLICIT tag at current level */
2103                 &asn_DEF_BIT_STRING,
2104                 0,
2105                 { &asn_OER_memb_four_four_one_TypeI_MultiPanel_Restriction_constr_33, &asn_PER_memb_four_four_one_TypeI_MultiPanel_Restriction_constr_33,  memb_four_four_one_TypeI_MultiPanel_Restriction_constraint_27 },
2106                 0, 0, /* No default value */
2107                 "four-four-one-TypeI-MultiPanel-Restriction"
2108                 },
2109         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.two_four_two_TypeI_MultiPanel_Restriction),
2110                 (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
2111                 -1,     /* IMPLICIT tag at current level */
2112                 &asn_DEF_BIT_STRING,
2113                 0,
2114                 { &asn_OER_memb_two_four_two_TypeI_MultiPanel_Restriction_constr_34, &asn_PER_memb_two_four_two_TypeI_MultiPanel_Restriction_constr_34,  memb_two_four_two_TypeI_MultiPanel_Restriction_constraint_27 },
2115                 0, 0, /* No default value */
2116                 "two-four-two-TypeI-MultiPanel-Restriction"
2117                 },
2118         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, choice.four_two_two_TypeI_MultiPanel_Restriction),
2119                 (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
2120                 -1,     /* IMPLICIT tag at current level */
2121                 &asn_DEF_BIT_STRING,
2122                 0,
2123                 { &asn_OER_memb_four_two_two_TypeI_MultiPanel_Restriction_constr_35, &asn_PER_memb_four_two_two_TypeI_MultiPanel_Restriction_constr_35,  memb_four_two_two_TypeI_MultiPanel_Restriction_constraint_27 },
2124                 0, 0, /* No default value */
2125                 "four-two-two-TypeI-MultiPanel-Restriction"
2126                 },
2127 };
2128 static const asn_TYPE_tag2member_t asn_MAP_ng_n1_n2_tag2el_27[] = {
2129     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* two-two-one-TypeI-MultiPanel-Restriction */
2130     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* two-four-one-TypeI-MultiPanel-Restriction */
2131     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* four-two-one-TypeI-MultiPanel-Restriction */
2132     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* two-two-two-TypeI-MultiPanel-Restriction */
2133     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* two-eight-one-TypeI-MultiPanel-Restriction */
2134     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* four-four-one-TypeI-MultiPanel-Restriction */
2135     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* two-four-two-TypeI-MultiPanel-Restriction */
2136     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 } /* four-two-two-TypeI-MultiPanel-Restriction */
2137 };
2138 static asn_CHOICE_specifics_t asn_SPC_ng_n1_n2_specs_27 = {
2139         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2),
2140         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, _asn_ctx),
2141         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2, present),
2142         sizeof(((struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel__ng_n1_n2 *)0)->present),
2143         asn_MAP_ng_n1_n2_tag2el_27,
2144         8,      /* Count of tags in the map */
2145         0, 0,
2146         -1      /* Extensions start */
2147 };
2148 static /* Use -fall-defs-global to expose */
2149 asn_TYPE_descriptor_t asn_DEF_ng_n1_n2_27 = {
2150         "ng-n1-n2",
2151         "ng-n1-n2",
2152         &asn_OP_CHOICE,
2153         0,      /* No effective tags (pointer) */
2154         0,      /* No effective tags (count) */
2155         0,      /* No tags (pointer) */
2156         0,      /* No tags (count) */
2157         { &asn_OER_type_ng_n1_n2_constr_27, &asn_PER_type_ng_n1_n2_constr_27, CHOICE_constraint },
2158         asn_MBR_ng_n1_n2_27,
2159         8,      /* Elements count */
2160         &asn_SPC_ng_n1_n2_specs_27      /* Additional specs */
2161 };
2162
2163 static asn_TYPE_member_t asn_MBR_typeI_MultiPanel_26[] = {
2164         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel, ng_n1_n2),
2165                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2166                 +1,     /* EXPLICIT tag at current level */
2167                 &asn_DEF_ng_n1_n2_27,
2168                 0,
2169                 { 0, 0, 0 },
2170                 0, 0, /* No default value */
2171                 "ng-n1-n2"
2172                 },
2173         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel, ri_Restriction),
2174                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2175                 -1,     /* IMPLICIT tag at current level */
2176                 &asn_DEF_BIT_STRING,
2177                 0,
2178                 { &asn_OER_memb_ri_Restriction_constr_36, &asn_PER_memb_ri_Restriction_constr_36,  memb_ri_Restriction_constraint_26 },
2179                 0, 0, /* No default value */
2180                 "ri-Restriction"
2181                 },
2182 };
2183 static const ber_tlv_tag_t asn_DEF_typeI_MultiPanel_tags_26[] = {
2184         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2185         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2186 };
2187 static const asn_TYPE_tag2member_t asn_MAP_typeI_MultiPanel_tag2el_26[] = {
2188     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ng-n1-n2 */
2189     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* ri-Restriction */
2190 };
2191 static asn_SEQUENCE_specifics_t asn_SPC_typeI_MultiPanel_specs_26 = {
2192         sizeof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel),
2193         offsetof(struct CodebookConfig__codebookType__type1__subType__typeI_MultiPanel, _asn_ctx),
2194         asn_MAP_typeI_MultiPanel_tag2el_26,
2195         2,      /* Count of tags in the map */
2196         0, 0, 0,        /* Optional elements (not needed) */
2197         -1,     /* First extension addition */
2198 };
2199 static /* Use -fall-defs-global to expose */
2200 asn_TYPE_descriptor_t asn_DEF_typeI_MultiPanel_26 = {
2201         "typeI-MultiPanel",
2202         "typeI-MultiPanel",
2203         &asn_OP_SEQUENCE,
2204         asn_DEF_typeI_MultiPanel_tags_26,
2205         sizeof(asn_DEF_typeI_MultiPanel_tags_26)
2206                 /sizeof(asn_DEF_typeI_MultiPanel_tags_26[0]) - 1, /* 1 */
2207         asn_DEF_typeI_MultiPanel_tags_26,       /* Same as above */
2208         sizeof(asn_DEF_typeI_MultiPanel_tags_26)
2209                 /sizeof(asn_DEF_typeI_MultiPanel_tags_26[0]), /* 2 */
2210         { 0, 0, SEQUENCE_constraint },
2211         asn_MBR_typeI_MultiPanel_26,
2212         2,      /* Elements count */
2213         &asn_SPC_typeI_MultiPanel_specs_26      /* Additional specs */
2214 };
2215
2216 static asn_TYPE_member_t asn_MBR_subType_4[] = {
2217         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType__type1__subType, choice.typeI_SinglePanel),
2218                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2219                 0,
2220                 &asn_DEF_typeI_SinglePanel_5,
2221                 0,
2222                 { 0, 0, 0 },
2223                 0, 0, /* No default value */
2224                 "typeI-SinglePanel"
2225                 },
2226         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType__type1__subType, choice.typeI_MultiPanel),
2227                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2228                 0,
2229                 &asn_DEF_typeI_MultiPanel_26,
2230                 0,
2231                 { 0, 0, 0 },
2232                 0, 0, /* No default value */
2233                 "typeI-MultiPanel"
2234                 },
2235 };
2236 static const asn_TYPE_tag2member_t asn_MAP_subType_tag2el_4[] = {
2237     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeI-SinglePanel */
2238     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* typeI-MultiPanel */
2239 };
2240 static asn_CHOICE_specifics_t asn_SPC_subType_specs_4 = {
2241         sizeof(struct CodebookConfig__codebookType__type1__subType),
2242         offsetof(struct CodebookConfig__codebookType__type1__subType, _asn_ctx),
2243         offsetof(struct CodebookConfig__codebookType__type1__subType, present),
2244         sizeof(((struct CodebookConfig__codebookType__type1__subType *)0)->present),
2245         asn_MAP_subType_tag2el_4,
2246         2,      /* Count of tags in the map */
2247         0, 0,
2248         -1      /* Extensions start */
2249 };
2250 static /* Use -fall-defs-global to expose */
2251 asn_TYPE_descriptor_t asn_DEF_subType_4 = {
2252         "subType",
2253         "subType",
2254         &asn_OP_CHOICE,
2255         0,      /* No effective tags (pointer) */
2256         0,      /* No effective tags (count) */
2257         0,      /* No tags (pointer) */
2258         0,      /* No tags (count) */
2259         { &asn_OER_type_subType_constr_4, &asn_PER_type_subType_constr_4, CHOICE_constraint },
2260         asn_MBR_subType_4,
2261         2,      /* Elements count */
2262         &asn_SPC_subType_specs_4        /* Additional specs */
2263 };
2264
2265 static asn_TYPE_member_t asn_MBR_type1_3[] = {
2266         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1, subType),
2267                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2268                 +1,     /* EXPLICIT tag at current level */
2269                 &asn_DEF_subType_4,
2270                 0,
2271                 { 0, 0, 0 },
2272                 0, 0, /* No default value */
2273                 "subType"
2274                 },
2275         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type1, codebookMode),
2276                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2277                 -1,     /* IMPLICIT tag at current level */
2278                 &asn_DEF_NativeInteger,
2279                 0,
2280                 { &asn_OER_memb_codebookMode_constr_37, &asn_PER_memb_codebookMode_constr_37,  memb_codebookMode_constraint_3 },
2281                 0, 0, /* No default value */
2282                 "codebookMode"
2283                 },
2284 };
2285 static const ber_tlv_tag_t asn_DEF_type1_tags_3[] = {
2286         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2287         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2288 };
2289 static const asn_TYPE_tag2member_t asn_MAP_type1_tag2el_3[] = {
2290     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* subType */
2291     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* codebookMode */
2292 };
2293 static asn_SEQUENCE_specifics_t asn_SPC_type1_specs_3 = {
2294         sizeof(struct CodebookConfig__codebookType__type1),
2295         offsetof(struct CodebookConfig__codebookType__type1, _asn_ctx),
2296         asn_MAP_type1_tag2el_3,
2297         2,      /* Count of tags in the map */
2298         0, 0, 0,        /* Optional elements (not needed) */
2299         -1,     /* First extension addition */
2300 };
2301 static /* Use -fall-defs-global to expose */
2302 asn_TYPE_descriptor_t asn_DEF_type1_3 = {
2303         "type1",
2304         "type1",
2305         &asn_OP_SEQUENCE,
2306         asn_DEF_type1_tags_3,
2307         sizeof(asn_DEF_type1_tags_3)
2308                 /sizeof(asn_DEF_type1_tags_3[0]) - 1, /* 1 */
2309         asn_DEF_type1_tags_3,   /* Same as above */
2310         sizeof(asn_DEF_type1_tags_3)
2311                 /sizeof(asn_DEF_type1_tags_3[0]), /* 2 */
2312         { 0, 0, SEQUENCE_constraint },
2313         asn_MBR_type1_3,
2314         2,      /* Elements count */
2315         &asn_SPC_type1_specs_3  /* Additional specs */
2316 };
2317
2318 static asn_TYPE_member_t asn_MBR_n1_n2_codebookSubsetRestriction_41[] = {
2319         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.two_one),
2320                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2321                 -1,     /* IMPLICIT tag at current level */
2322                 &asn_DEF_BIT_STRING,
2323                 0,
2324                 { &asn_OER_memb_two_one_constr_42, &asn_PER_memb_two_one_constr_42,  memb_two_one_constraint_41 },
2325                 0, 0, /* No default value */
2326                 "two-one"
2327                 },
2328         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.two_two),
2329                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2330                 -1,     /* IMPLICIT tag at current level */
2331                 &asn_DEF_BIT_STRING,
2332                 0,
2333                 { &asn_OER_memb_two_two_constr_43, &asn_PER_memb_two_two_constr_43,  memb_two_two_constraint_41 },
2334                 0, 0, /* No default value */
2335                 "two-two"
2336                 },
2337         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.four_one),
2338                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
2339                 -1,     /* IMPLICIT tag at current level */
2340                 &asn_DEF_BIT_STRING,
2341                 0,
2342                 { &asn_OER_memb_four_one_constr_44, &asn_PER_memb_four_one_constr_44,  memb_four_one_constraint_41 },
2343                 0, 0, /* No default value */
2344                 "four-one"
2345                 },
2346         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.three_two),
2347                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
2348                 -1,     /* IMPLICIT tag at current level */
2349                 &asn_DEF_BIT_STRING,
2350                 0,
2351                 { &asn_OER_memb_three_two_constr_45, &asn_PER_memb_three_two_constr_45,  memb_three_two_constraint_41 },
2352                 0, 0, /* No default value */
2353                 "three-two"
2354                 },
2355         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.six_one),
2356                 (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
2357                 -1,     /* IMPLICIT tag at current level */
2358                 &asn_DEF_BIT_STRING,
2359                 0,
2360                 { &asn_OER_memb_six_one_constr_46, &asn_PER_memb_six_one_constr_46,  memb_six_one_constraint_41 },
2361                 0, 0, /* No default value */
2362                 "six-one"
2363                 },
2364         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.four_two),
2365                 (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
2366                 -1,     /* IMPLICIT tag at current level */
2367                 &asn_DEF_BIT_STRING,
2368                 0,
2369                 { &asn_OER_memb_four_two_constr_47, &asn_PER_memb_four_two_constr_47,  memb_four_two_constraint_41 },
2370                 0, 0, /* No default value */
2371                 "four-two"
2372                 },
2373         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.eight_one),
2374                 (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
2375                 -1,     /* IMPLICIT tag at current level */
2376                 &asn_DEF_BIT_STRING,
2377                 0,
2378                 { &asn_OER_memb_eight_one_constr_48, &asn_PER_memb_eight_one_constr_48,  memb_eight_one_constraint_41 },
2379                 0, 0, /* No default value */
2380                 "eight-one"
2381                 },
2382         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.four_three),
2383                 (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
2384                 -1,     /* IMPLICIT tag at current level */
2385                 &asn_DEF_BIT_STRING,
2386                 0,
2387                 { &asn_OER_memb_four_three_constr_49, &asn_PER_memb_four_three_constr_49,  memb_four_three_constraint_41 },
2388                 0, 0, /* No default value */
2389                 "four-three"
2390                 },
2391         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.six_two),
2392                 (ASN_TAG_CLASS_CONTEXT | (8 << 2)),
2393                 -1,     /* IMPLICIT tag at current level */
2394                 &asn_DEF_BIT_STRING,
2395                 0,
2396                 { &asn_OER_memb_six_two_constr_50, &asn_PER_memb_six_two_constr_50,  memb_six_two_constraint_41 },
2397                 0, 0, /* No default value */
2398                 "six-two"
2399                 },
2400         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.twelve_one),
2401                 (ASN_TAG_CLASS_CONTEXT | (9 << 2)),
2402                 -1,     /* IMPLICIT tag at current level */
2403                 &asn_DEF_BIT_STRING,
2404                 0,
2405                 { &asn_OER_memb_twelve_one_constr_51, &asn_PER_memb_twelve_one_constr_51,  memb_twelve_one_constraint_41 },
2406                 0, 0, /* No default value */
2407                 "twelve-one"
2408                 },
2409         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.four_four),
2410                 (ASN_TAG_CLASS_CONTEXT | (10 << 2)),
2411                 -1,     /* IMPLICIT tag at current level */
2412                 &asn_DEF_BIT_STRING,
2413                 0,
2414                 { &asn_OER_memb_four_four_constr_52, &asn_PER_memb_four_four_constr_52,  memb_four_four_constraint_41 },
2415                 0, 0, /* No default value */
2416                 "four-four"
2417                 },
2418         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.eight_two),
2419                 (ASN_TAG_CLASS_CONTEXT | (11 << 2)),
2420                 -1,     /* IMPLICIT tag at current level */
2421                 &asn_DEF_BIT_STRING,
2422                 0,
2423                 { &asn_OER_memb_eight_two_constr_53, &asn_PER_memb_eight_two_constr_53,  memb_eight_two_constraint_41 },
2424                 0, 0, /* No default value */
2425                 "eight-two"
2426                 },
2427         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, choice.sixteen_one),
2428                 (ASN_TAG_CLASS_CONTEXT | (12 << 2)),
2429                 -1,     /* IMPLICIT tag at current level */
2430                 &asn_DEF_BIT_STRING,
2431                 0,
2432                 { &asn_OER_memb_sixteen_one_constr_54, &asn_PER_memb_sixteen_one_constr_54,  memb_sixteen_one_constraint_41 },
2433                 0, 0, /* No default value */
2434                 "sixteen-one"
2435                 },
2436 };
2437 static const asn_TYPE_tag2member_t asn_MAP_n1_n2_codebookSubsetRestriction_tag2el_41[] = {
2438     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* two-one */
2439     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* two-two */
2440     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* four-one */
2441     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* three-two */
2442     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* six-one */
2443     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* four-two */
2444     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* eight-one */
2445     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* four-three */
2446     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* six-two */
2447     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* twelve-one */
2448     { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* four-four */
2449     { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 }, /* eight-two */
2450     { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 12, 0, 0 } /* sixteen-one */
2451 };
2452 static asn_CHOICE_specifics_t asn_SPC_n1_n2_codebookSubsetRestriction_specs_41 = {
2453         sizeof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction),
2454         offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, _asn_ctx),
2455         offsetof(struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction, present),
2456         sizeof(((struct CodebookConfig__codebookType__type2__subType__typeII__n1_n2_codebookSubsetRestriction *)0)->present),
2457         asn_MAP_n1_n2_codebookSubsetRestriction_tag2el_41,
2458         13,     /* Count of tags in the map */
2459         0, 0,
2460         -1      /* Extensions start */
2461 };
2462 static /* Use -fall-defs-global to expose */
2463 asn_TYPE_descriptor_t asn_DEF_n1_n2_codebookSubsetRestriction_41 = {
2464         "n1-n2-codebookSubsetRestriction",
2465         "n1-n2-codebookSubsetRestriction",
2466         &asn_OP_CHOICE,
2467         0,      /* No effective tags (pointer) */
2468         0,      /* No effective tags (count) */
2469         0,      /* No tags (pointer) */
2470         0,      /* No tags (count) */
2471         { &asn_OER_type_n1_n2_codebookSubsetRestriction_constr_41, &asn_PER_type_n1_n2_codebookSubsetRestriction_constr_41, CHOICE_constraint },
2472         asn_MBR_n1_n2_codebookSubsetRestriction_41,
2473         13,     /* Elements count */
2474         &asn_SPC_n1_n2_codebookSubsetRestriction_specs_41       /* Additional specs */
2475 };
2476
2477 static asn_TYPE_member_t asn_MBR_typeII_40[] = {
2478         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII, n1_n2_codebookSubsetRestriction),
2479                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2480                 +1,     /* EXPLICIT tag at current level */
2481                 &asn_DEF_n1_n2_codebookSubsetRestriction_41,
2482                 0,
2483                 { 0, 0, 0 },
2484                 0, 0, /* No default value */
2485                 "n1-n2-codebookSubsetRestriction"
2486                 },
2487         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII, typeII_RI_Restriction),
2488                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2489                 -1,     /* IMPLICIT tag at current level */
2490                 &asn_DEF_BIT_STRING,
2491                 0,
2492                 { &asn_OER_memb_typeII_RI_Restriction_constr_55, &asn_PER_memb_typeII_RI_Restriction_constr_55,  memb_typeII_RI_Restriction_constraint_40 },
2493                 0, 0, /* No default value */
2494                 "typeII-RI-Restriction"
2495                 },
2496 };
2497 static const ber_tlv_tag_t asn_DEF_typeII_tags_40[] = {
2498         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2499         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2500 };
2501 static const asn_TYPE_tag2member_t asn_MAP_typeII_tag2el_40[] = {
2502     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* n1-n2-codebookSubsetRestriction */
2503     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* typeII-RI-Restriction */
2504 };
2505 static asn_SEQUENCE_specifics_t asn_SPC_typeII_specs_40 = {
2506         sizeof(struct CodebookConfig__codebookType__type2__subType__typeII),
2507         offsetof(struct CodebookConfig__codebookType__type2__subType__typeII, _asn_ctx),
2508         asn_MAP_typeII_tag2el_40,
2509         2,      /* Count of tags in the map */
2510         0, 0, 0,        /* Optional elements (not needed) */
2511         -1,     /* First extension addition */
2512 };
2513 static /* Use -fall-defs-global to expose */
2514 asn_TYPE_descriptor_t asn_DEF_typeII_40 = {
2515         "typeII",
2516         "typeII",
2517         &asn_OP_SEQUENCE,
2518         asn_DEF_typeII_tags_40,
2519         sizeof(asn_DEF_typeII_tags_40)
2520                 /sizeof(asn_DEF_typeII_tags_40[0]) - 1, /* 1 */
2521         asn_DEF_typeII_tags_40, /* Same as above */
2522         sizeof(asn_DEF_typeII_tags_40)
2523                 /sizeof(asn_DEF_typeII_tags_40[0]), /* 2 */
2524         { 0, 0, SEQUENCE_constraint },
2525         asn_MBR_typeII_40,
2526         2,      /* Elements count */
2527         &asn_SPC_typeII_specs_40        /* Additional specs */
2528 };
2529
2530 static const asn_INTEGER_enum_map_t asn_MAP_portSelectionSamplingSize_value2enum_57[] = {
2531         { 0,    2,      "n1" },
2532         { 1,    2,      "n2" },
2533         { 2,    2,      "n3" },
2534         { 3,    2,      "n4" }
2535 };
2536 static const unsigned int asn_MAP_portSelectionSamplingSize_enum2value_57[] = {
2537         0,      /* n1(0) */
2538         1,      /* n2(1) */
2539         2,      /* n3(2) */
2540         3       /* n4(3) */
2541 };
2542 static const asn_INTEGER_specifics_t asn_SPC_portSelectionSamplingSize_specs_57 = {
2543         asn_MAP_portSelectionSamplingSize_value2enum_57,        /* "tag" => N; sorted by tag */
2544         asn_MAP_portSelectionSamplingSize_enum2value_57,        /* N => "tag"; sorted by N */
2545         4,      /* Number of elements in the maps */
2546         0,      /* Enumeration is not extensible */
2547         1,      /* Strict enumeration */
2548         0,      /* Native long size */
2549         0
2550 };
2551 static const ber_tlv_tag_t asn_DEF_portSelectionSamplingSize_tags_57[] = {
2552         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2553         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
2554 };
2555 static /* Use -fall-defs-global to expose */
2556 asn_TYPE_descriptor_t asn_DEF_portSelectionSamplingSize_57 = {
2557         "portSelectionSamplingSize",
2558         "portSelectionSamplingSize",
2559         &asn_OP_NativeEnumerated,
2560         asn_DEF_portSelectionSamplingSize_tags_57,
2561         sizeof(asn_DEF_portSelectionSamplingSize_tags_57)
2562                 /sizeof(asn_DEF_portSelectionSamplingSize_tags_57[0]) - 1, /* 1 */
2563         asn_DEF_portSelectionSamplingSize_tags_57,      /* Same as above */
2564         sizeof(asn_DEF_portSelectionSamplingSize_tags_57)
2565                 /sizeof(asn_DEF_portSelectionSamplingSize_tags_57[0]), /* 2 */
2566         { &asn_OER_type_portSelectionSamplingSize_constr_57, &asn_PER_type_portSelectionSamplingSize_constr_57, NativeEnumerated_constraint },
2567         0, 0,   /* Defined elsewhere */
2568         &asn_SPC_portSelectionSamplingSize_specs_57     /* Additional specs */
2569 };
2570
2571 static asn_TYPE_member_t asn_MBR_typeII_PortSelection_56[] = {
2572         { ATF_POINTER, 1, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII_PortSelection, portSelectionSamplingSize),
2573                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2574                 -1,     /* IMPLICIT tag at current level */
2575                 &asn_DEF_portSelectionSamplingSize_57,
2576                 0,
2577                 { 0, 0, 0 },
2578                 0, 0, /* No default value */
2579                 "portSelectionSamplingSize"
2580                 },
2581         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2__subType__typeII_PortSelection, typeII_PortSelectionRI_Restriction),
2582                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2583                 -1,     /* IMPLICIT tag at current level */
2584                 &asn_DEF_BIT_STRING,
2585                 0,
2586                 { &asn_OER_memb_typeII_PortSelectionRI_Restriction_constr_62, &asn_PER_memb_typeII_PortSelectionRI_Restriction_constr_62,  memb_typeII_PortSelectionRI_Restriction_constraint_56 },
2587                 0, 0, /* No default value */
2588                 "typeII-PortSelectionRI-Restriction"
2589                 },
2590 };
2591 static const int asn_MAP_typeII_PortSelection_oms_56[] = { 0 };
2592 static const ber_tlv_tag_t asn_DEF_typeII_PortSelection_tags_56[] = {
2593         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2594         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2595 };
2596 static const asn_TYPE_tag2member_t asn_MAP_typeII_PortSelection_tag2el_56[] = {
2597     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* portSelectionSamplingSize */
2598     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* typeII-PortSelectionRI-Restriction */
2599 };
2600 static asn_SEQUENCE_specifics_t asn_SPC_typeII_PortSelection_specs_56 = {
2601         sizeof(struct CodebookConfig__codebookType__type2__subType__typeII_PortSelection),
2602         offsetof(struct CodebookConfig__codebookType__type2__subType__typeII_PortSelection, _asn_ctx),
2603         asn_MAP_typeII_PortSelection_tag2el_56,
2604         2,      /* Count of tags in the map */
2605         asn_MAP_typeII_PortSelection_oms_56,    /* Optional members */
2606         1, 0,   /* Root/Additions */
2607         -1,     /* First extension addition */
2608 };
2609 static /* Use -fall-defs-global to expose */
2610 asn_TYPE_descriptor_t asn_DEF_typeII_PortSelection_56 = {
2611         "typeII-PortSelection",
2612         "typeII-PortSelection",
2613         &asn_OP_SEQUENCE,
2614         asn_DEF_typeII_PortSelection_tags_56,
2615         sizeof(asn_DEF_typeII_PortSelection_tags_56)
2616                 /sizeof(asn_DEF_typeII_PortSelection_tags_56[0]) - 1, /* 1 */
2617         asn_DEF_typeII_PortSelection_tags_56,   /* Same as above */
2618         sizeof(asn_DEF_typeII_PortSelection_tags_56)
2619                 /sizeof(asn_DEF_typeII_PortSelection_tags_56[0]), /* 2 */
2620         { 0, 0, SEQUENCE_constraint },
2621         asn_MBR_typeII_PortSelection_56,
2622         2,      /* Elements count */
2623         &asn_SPC_typeII_PortSelection_specs_56  /* Additional specs */
2624 };
2625
2626 static asn_TYPE_member_t asn_MBR_subType_39[] = {
2627         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType__type2__subType, choice.typeII),
2628                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2629                 0,
2630                 &asn_DEF_typeII_40,
2631                 0,
2632                 { 0, 0, 0 },
2633                 0, 0, /* No default value */
2634                 "typeII"
2635                 },
2636         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType__type2__subType, choice.typeII_PortSelection),
2637                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2638                 0,
2639                 &asn_DEF_typeII_PortSelection_56,
2640                 0,
2641                 { 0, 0, 0 },
2642                 0, 0, /* No default value */
2643                 "typeII-PortSelection"
2644                 },
2645 };
2646 static const asn_TYPE_tag2member_t asn_MAP_subType_tag2el_39[] = {
2647     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeII */
2648     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* typeII-PortSelection */
2649 };
2650 static asn_CHOICE_specifics_t asn_SPC_subType_specs_39 = {
2651         sizeof(struct CodebookConfig__codebookType__type2__subType),
2652         offsetof(struct CodebookConfig__codebookType__type2__subType, _asn_ctx),
2653         offsetof(struct CodebookConfig__codebookType__type2__subType, present),
2654         sizeof(((struct CodebookConfig__codebookType__type2__subType *)0)->present),
2655         asn_MAP_subType_tag2el_39,
2656         2,      /* Count of tags in the map */
2657         0, 0,
2658         -1      /* Extensions start */
2659 };
2660 static /* Use -fall-defs-global to expose */
2661 asn_TYPE_descriptor_t asn_DEF_subType_39 = {
2662         "subType",
2663         "subType",
2664         &asn_OP_CHOICE,
2665         0,      /* No effective tags (pointer) */
2666         0,      /* No effective tags (count) */
2667         0,      /* No tags (pointer) */
2668         0,      /* No tags (count) */
2669         { &asn_OER_type_subType_constr_39, &asn_PER_type_subType_constr_39, CHOICE_constraint },
2670         asn_MBR_subType_39,
2671         2,      /* Elements count */
2672         &asn_SPC_subType_specs_39       /* Additional specs */
2673 };
2674
2675 static const asn_INTEGER_enum_map_t asn_MAP_phaseAlphabetSize_value2enum_63[] = {
2676         { 0,    2,      "n4" },
2677         { 1,    2,      "n8" }
2678 };
2679 static const unsigned int asn_MAP_phaseAlphabetSize_enum2value_63[] = {
2680         0,      /* n4(0) */
2681         1       /* n8(1) */
2682 };
2683 static const asn_INTEGER_specifics_t asn_SPC_phaseAlphabetSize_specs_63 = {
2684         asn_MAP_phaseAlphabetSize_value2enum_63,        /* "tag" => N; sorted by tag */
2685         asn_MAP_phaseAlphabetSize_enum2value_63,        /* N => "tag"; sorted by N */
2686         2,      /* Number of elements in the maps */
2687         0,      /* Enumeration is not extensible */
2688         1,      /* Strict enumeration */
2689         0,      /* Native long size */
2690         0
2691 };
2692 static const ber_tlv_tag_t asn_DEF_phaseAlphabetSize_tags_63[] = {
2693         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2694         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
2695 };
2696 static /* Use -fall-defs-global to expose */
2697 asn_TYPE_descriptor_t asn_DEF_phaseAlphabetSize_63 = {
2698         "phaseAlphabetSize",
2699         "phaseAlphabetSize",
2700         &asn_OP_NativeEnumerated,
2701         asn_DEF_phaseAlphabetSize_tags_63,
2702         sizeof(asn_DEF_phaseAlphabetSize_tags_63)
2703                 /sizeof(asn_DEF_phaseAlphabetSize_tags_63[0]) - 1, /* 1 */
2704         asn_DEF_phaseAlphabetSize_tags_63,      /* Same as above */
2705         sizeof(asn_DEF_phaseAlphabetSize_tags_63)
2706                 /sizeof(asn_DEF_phaseAlphabetSize_tags_63[0]), /* 2 */
2707         { &asn_OER_type_phaseAlphabetSize_constr_63, &asn_PER_type_phaseAlphabetSize_constr_63, NativeEnumerated_constraint },
2708         0, 0,   /* Defined elsewhere */
2709         &asn_SPC_phaseAlphabetSize_specs_63     /* Additional specs */
2710 };
2711
2712 static const asn_INTEGER_enum_map_t asn_MAP_numberOfBeams_value2enum_67[] = {
2713         { 0,    3,      "two" },
2714         { 1,    5,      "three" },
2715         { 2,    4,      "four" }
2716 };
2717 static const unsigned int asn_MAP_numberOfBeams_enum2value_67[] = {
2718         2,      /* four(2) */
2719         1,      /* three(1) */
2720         0       /* two(0) */
2721 };
2722 static const asn_INTEGER_specifics_t asn_SPC_numberOfBeams_specs_67 = {
2723         asn_MAP_numberOfBeams_value2enum_67,    /* "tag" => N; sorted by tag */
2724         asn_MAP_numberOfBeams_enum2value_67,    /* N => "tag"; sorted by N */
2725         3,      /* Number of elements in the maps */
2726         0,      /* Enumeration is not extensible */
2727         1,      /* Strict enumeration */
2728         0,      /* Native long size */
2729         0
2730 };
2731 static const ber_tlv_tag_t asn_DEF_numberOfBeams_tags_67[] = {
2732         (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
2733         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
2734 };
2735 static /* Use -fall-defs-global to expose */
2736 asn_TYPE_descriptor_t asn_DEF_numberOfBeams_67 = {
2737         "numberOfBeams",
2738         "numberOfBeams",
2739         &asn_OP_NativeEnumerated,
2740         asn_DEF_numberOfBeams_tags_67,
2741         sizeof(asn_DEF_numberOfBeams_tags_67)
2742                 /sizeof(asn_DEF_numberOfBeams_tags_67[0]) - 1, /* 1 */
2743         asn_DEF_numberOfBeams_tags_67,  /* Same as above */
2744         sizeof(asn_DEF_numberOfBeams_tags_67)
2745                 /sizeof(asn_DEF_numberOfBeams_tags_67[0]), /* 2 */
2746         { &asn_OER_type_numberOfBeams_constr_67, &asn_PER_type_numberOfBeams_constr_67, NativeEnumerated_constraint },
2747         0, 0,   /* Defined elsewhere */
2748         &asn_SPC_numberOfBeams_specs_67 /* Additional specs */
2749 };
2750
2751 static asn_TYPE_member_t asn_MBR_type2_38[] = {
2752         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2, subType),
2753                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2754                 +1,     /* EXPLICIT tag at current level */
2755                 &asn_DEF_subType_39,
2756                 0,
2757                 { 0, 0, 0 },
2758                 0, 0, /* No default value */
2759                 "subType"
2760                 },
2761         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2, phaseAlphabetSize),
2762                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2763                 -1,     /* IMPLICIT tag at current level */
2764                 &asn_DEF_phaseAlphabetSize_63,
2765                 0,
2766                 { 0, 0, 0 },
2767                 0, 0, /* No default value */
2768                 "phaseAlphabetSize"
2769                 },
2770         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2, subbandAmplitude),
2771                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
2772                 -1,     /* IMPLICIT tag at current level */
2773                 &asn_DEF_BOOLEAN,
2774                 0,
2775                 { 0, 0, 0 },
2776                 0, 0, /* No default value */
2777                 "subbandAmplitude"
2778                 },
2779         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig__codebookType__type2, numberOfBeams),
2780                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
2781                 -1,     /* IMPLICIT tag at current level */
2782                 &asn_DEF_numberOfBeams_67,
2783                 0,
2784                 { 0, 0, 0 },
2785                 0, 0, /* No default value */
2786                 "numberOfBeams"
2787                 },
2788 };
2789 static const ber_tlv_tag_t asn_DEF_type2_tags_38[] = {
2790         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2791         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2792 };
2793 static const asn_TYPE_tag2member_t asn_MAP_type2_tag2el_38[] = {
2794     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* subType */
2795     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* phaseAlphabetSize */
2796     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* subbandAmplitude */
2797     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* numberOfBeams */
2798 };
2799 static asn_SEQUENCE_specifics_t asn_SPC_type2_specs_38 = {
2800         sizeof(struct CodebookConfig__codebookType__type2),
2801         offsetof(struct CodebookConfig__codebookType__type2, _asn_ctx),
2802         asn_MAP_type2_tag2el_38,
2803         4,      /* Count of tags in the map */
2804         0, 0, 0,        /* Optional elements (not needed) */
2805         -1,     /* First extension addition */
2806 };
2807 static /* Use -fall-defs-global to expose */
2808 asn_TYPE_descriptor_t asn_DEF_type2_38 = {
2809         "type2",
2810         "type2",
2811         &asn_OP_SEQUENCE,
2812         asn_DEF_type2_tags_38,
2813         sizeof(asn_DEF_type2_tags_38)
2814                 /sizeof(asn_DEF_type2_tags_38[0]) - 1, /* 1 */
2815         asn_DEF_type2_tags_38,  /* Same as above */
2816         sizeof(asn_DEF_type2_tags_38)
2817                 /sizeof(asn_DEF_type2_tags_38[0]), /* 2 */
2818         { 0, 0, SEQUENCE_constraint },
2819         asn_MBR_type2_38,
2820         4,      /* Elements count */
2821         &asn_SPC_type2_specs_38 /* Additional specs */
2822 };
2823
2824 static asn_TYPE_member_t asn_MBR_codebookType_2[] = {
2825         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType, choice.type1),
2826                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2827                 0,
2828                 &asn_DEF_type1_3,
2829                 0,
2830                 { 0, 0, 0 },
2831                 0, 0, /* No default value */
2832                 "type1"
2833                 },
2834         { ATF_POINTER, 0, offsetof(struct CodebookConfig__codebookType, choice.type2),
2835                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
2836                 0,
2837                 &asn_DEF_type2_38,
2838                 0,
2839                 { 0, 0, 0 },
2840                 0, 0, /* No default value */
2841                 "type2"
2842                 },
2843 };
2844 static const asn_TYPE_tag2member_t asn_MAP_codebookType_tag2el_2[] = {
2845     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* type1 */
2846     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* type2 */
2847 };
2848 static asn_CHOICE_specifics_t asn_SPC_codebookType_specs_2 = {
2849         sizeof(struct CodebookConfig__codebookType),
2850         offsetof(struct CodebookConfig__codebookType, _asn_ctx),
2851         offsetof(struct CodebookConfig__codebookType, present),
2852         sizeof(((struct CodebookConfig__codebookType *)0)->present),
2853         asn_MAP_codebookType_tag2el_2,
2854         2,      /* Count of tags in the map */
2855         0, 0,
2856         -1      /* Extensions start */
2857 };
2858 static /* Use -fall-defs-global to expose */
2859 asn_TYPE_descriptor_t asn_DEF_codebookType_2 = {
2860         "codebookType",
2861         "codebookType",
2862         &asn_OP_CHOICE,
2863         0,      /* No effective tags (pointer) */
2864         0,      /* No effective tags (count) */
2865         0,      /* No tags (pointer) */
2866         0,      /* No tags (count) */
2867         { &asn_OER_type_codebookType_constr_2, &asn_PER_type_codebookType_constr_2, CHOICE_constraint },
2868         asn_MBR_codebookType_2,
2869         2,      /* Elements count */
2870         &asn_SPC_codebookType_specs_2   /* Additional specs */
2871 };
2872
2873 asn_TYPE_member_t asn_MBR_CodebookConfig_1[] = {
2874         { ATF_NOFLAGS, 0, offsetof(struct CodebookConfig, codebookType),
2875                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
2876                 +1,     /* EXPLICIT tag at current level */
2877                 &asn_DEF_codebookType_2,
2878                 0,
2879                 { 0, 0, 0 },
2880                 0, 0, /* No default value */
2881                 "codebookType"
2882                 },
2883 };
2884 static const ber_tlv_tag_t asn_DEF_CodebookConfig_tags_1[] = {
2885         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
2886 };
2887 static const asn_TYPE_tag2member_t asn_MAP_CodebookConfig_tag2el_1[] = {
2888     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* codebookType */
2889 };
2890 asn_SEQUENCE_specifics_t asn_SPC_CodebookConfig_specs_1 = {
2891         sizeof(struct CodebookConfig),
2892         offsetof(struct CodebookConfig, _asn_ctx),
2893         asn_MAP_CodebookConfig_tag2el_1,
2894         1,      /* Count of tags in the map */
2895         0, 0, 0,        /* Optional elements (not needed) */
2896         -1,     /* First extension addition */
2897 };
2898 asn_TYPE_descriptor_t asn_DEF_CodebookConfig = {
2899         "CodebookConfig",
2900         "CodebookConfig",
2901         &asn_OP_SEQUENCE,
2902         asn_DEF_CodebookConfig_tags_1,
2903         sizeof(asn_DEF_CodebookConfig_tags_1)
2904                 /sizeof(asn_DEF_CodebookConfig_tags_1[0]), /* 1 */
2905         asn_DEF_CodebookConfig_tags_1,  /* Same as above */
2906         sizeof(asn_DEF_CodebookConfig_tags_1)
2907                 /sizeof(asn_DEF_CodebookConfig_tags_1[0]), /* 1 */
2908         { 0, 0, SEQUENCE_constraint },
2909         asn_MBR_CodebookConfig_1,
2910         1,      /* Elements count */
2911         &asn_SPC_CodebookConfig_specs_1 /* Additional specs */
2912 };
2913