Cell down alarm notification [Issue-Id: ODUHIGH-430]
[o-du/l2.git] / 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 "../../../rrc_15.3_asn.asn1"
5  *      `asn1c -D ./25_02_2022_RRC/ -fcompound-names -fno-include-deps -findirect-choice -gen-PER -no-gen-example`
6  */
7
8 #include "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